(PHP 4 >= 4.0.2, PHP 5)

mcrypt_encryptChiffre un texte


string mcrypt_encrypt ( string $cipher , string $key , string $data , string $mode [, string $iv ] )

mcrypt_encrypt() chiffre les données, et retourne les données chiffrées.

Liste de paramètres


Une constante parmi les constantes MCRYPT_ciphername, ou le nom de l'algorithme, sous la forme d'une chaîne de caractères.


La clé avec laquelle les données seront chiffrées. Si elle est plus petite que sa taille demandée, elle sera complétée avec des '\0'. Il est mieux de ne pas utiliser des clés ASCII.

Il est recommandé d'utiliser les fonctions mhash pour créer des clés à partir d'une chaîne.


Les données qui seront chiffrées, avec le cipher et le mode indiqué. Si la taille des données n'est pas un multiple de la taille de bloc, les données seront complétées par des caractères '\0', autant que nécessaire.

Le texte chiffré retourné peut être plus long que la taille des données passées en argument via data.


Une constantes parmi les constantes MCRYPT_MODE_modename, ou une des chaînes suivantes : "ecb", "cbc", "cfb", "ofb", "nofb" ou "stream".


Utilisé pour l'initialisation des modes CBC, CFB, OFB, ainsi que dans quelques algorithmes du mode STREAM. Si vous ne fournissez pas un IV, alors que cela est nécessaire pour l'algorithme, la fonction émettra une alerte et utilisera un IV dont tous les octets vaudront "\0".

Valeurs de retour

Retourne les données chiffrées, sous forme de chaîne de caractères.


Exemple #1 Exemple avec mcrypt_encrypt()


    # la clé devrait être un binaire aléatoire, utilisez la fonction scrypt, bcrypt
    # ou PBKDF2 pour convertir une chaîne de caractères en une clé.
    # La clé est spécifiée en utilisant une notation héxadécimale.
$key pack('H*'"bcb04b7e103a0cd8b54763051cef08bc55abe029fdebae5e1d417e2ffb2a00a3");
# Montre la taille de la clé utilisée ; soit des clés sur 16, 24 ou 32 octets pour
    # AES-128, 192 et 256 respectivement.
$key_size =  strlen($key);
"Talle de la clé : " $key_size "\n";
$plaintext "Cette chaîne de caractère a été chiffrée en AES-256 / CBC / ZeroBytePadding.";

# Crée un IV aléatoire à utiliser avec l'encodage CBC
$iv_size mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128MCRYPT_MODE_CBC);
$iv mcrypt_create_iv($iv_sizeMCRYPT_RAND);
# Crée un texte cipher compatible avec AES (Rijndael block size = 128)
    # pour conserver le texte confidentiel.
    # Uniquement applicable pour les entrées encodées qui ne se terminent jamais
    # pas la valeur 00h (en raison de la suppression par défaut des zéros finaux)
$ciphertext mcrypt_encrypt(MCRYPT_RIJNDAEL_128$key,

# On ajoute à la fin le IV pour le rendre disponible pour le chiffrement
$ciphertext $iv $ciphertext;
# Encode le texte du cipher résultant pouvant être représenté ainsi sous forme de chaîne de caractères
$ciphertext_base64 base64_encode($ciphertext);

$ciphertext_base64 "\n";

# === ATTENTION ===

    # Le texte du cipher résultant ne contient aucune intégrité ni d'authentification
    # et il n'est pas protégé par des attaques de type "oracle padding".
    # --- DECHIFFREMENT ---
$ciphertext_dec base64_decode($ciphertext_base64);
# Récupère le IV, iv_size doit avoir été créé en utilisant la fonction
    # mcrypt_get_iv_size()
$iv_dec substr($ciphertext_dec0$iv_size);
# Récupère le texte du cipher (tout, sauf $iv_size du début)
$ciphertext_dec substr($ciphertext_dec$iv_size);

# On doit supprimer les caractères de valeur 00h de la fin du texte plein
$plaintext_dec mcrypt_decrypt(MCRYPT_RIJNDAEL_128$key,
$plaintext_dec "\n";

L'exemple ci-dessus va afficher :

Talle de la clé : 32
Cette chaîne de caractère a été chiffrée en AES-256 / CBC / ZeroBytePadding.

Voir aussi mcrypt_module_open() pour une meilleure API et un exemple.

add a note add a note

User Contributed Notes 12 notes

Scott.a.Herbert at
2 years ago
It is always better to use a standard encryption cipher's rather than to "roll your own", firstly the standard cipher has been tested by world class crypto-analysis's where as unless your a world class crypto-analysis (and if you are why are you even thinking of rolling your own?!?) you won't have the skills needed to even test it (for example if you just XOR each character with a key, it may look secure (the text will be different) but if you count the number of times a character is repeated you see whatever the letter "E" encrypts to occurs more often then the encrypted "Z" (assuming English language plain text)

Secondly, you may think that the hidden nature of your cipher makes it more secure, but the fact is that your cipher is likely *only* secure because it's secret, if someone what able to break-in to your site and steal your code (but not your key) they maybe able break you encrypted data, if someone broke in and found you where using Blowfish (for example) it wouldn't help them.
dylan at wedefy dot com
7 years ago
I wasn't too impressed with the suggested functions/classes for using mcrypt, so I wrote my own class.  The encypted output is base64 encoded so it can be used in URLs, emails, etc.  MCRYPT_RIJNDAEL_256 is probably too secure for most uses, using a less secure algorithm should mean that the encryption will be faster and the encrypted output shorter (make sure to update iv_size in mcrypt_create_iv() and key length to match the new algorithm).  If you are going to use only 1 passphrase, you should define it inside __construct($this->securekey) instead of when creating the object. Keep the class in a separate include file which is only readable by your webserver (or whatever needs it) for added security.

class Cipher {
$securekey, $iv;
__construct($textkey) {
$this->securekey = hash('sha256',$textkey,TRUE);
$this->iv = mcrypt_create_iv(32);
encrypt($input) {
base64_encode(mcrypt_encrypt(MCRYPT_RIJNDAEL_256, $this->securekey, $input, MCRYPT_MODE_ECB, $this->iv));
decrypt($input) {
trim(mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $this->securekey, base64_decode($input), MCRYPT_MODE_ECB, $this->iv));

$cipher = new Cipher('secret passphrase');

$encryptedtext = $cipher->encrypt("hide me");
"->encrypt = $encryptedtext<br />";

$decryptedtext = $cipher->decrypt($encryptedtext);
"->decrypt = $decryptedtext<br />";

3 years ago
In the other notes there are some misconceptions about crypto and the IV, especially for CBC mode.

The most important point: Encryption DOES NOT provide any proof of data integrity or authentication WHATSOEVER. If you need to be sure that the data is secret and not tampered with, you need to encrypt THEN use a keyed HMAC.

For CBC mode, the IV DOES NOT need to be secret. It can be sent along with the plaintext. It needs to be UNIQUE and RANDOM. So that every message is encrypted with a different IV.

The best way to generate an IV is to use mcrypt_create_iv().

Keys must be binary, not ASCII. To create a key from a password:

= "MyPassword!1!";
$aes256Key = hash("SHA256", $password, true); //we want a 32 byte binary blob
jesse at pctest dot com
10 years ago
Solving 3DES incompatibilities with .NET's TripleDESCryptoServiceProvider

mcrypt's 3DES only accepts 192 bit keys, but Microsoft's .NET and many other tools accept both 128 and 192 bit keys.
If your key is too short, mcrypt will 'helpfully' pad null characters onto the end, but .NET refuses to use a key where the last third is all null (this is a Bad Key). This prevents you from emulating mcrypt's "short key" behaviour in .NET.

How to reconcile this? A little DES theory is in order
3DES runs the DES algorithm three times, using each third of your 192 bit key as the 64 bit DES key

Encrypt Key1 -> Decrypt Key2 -> Encrypt Key3

and both .NET and PHP's mcrypt do this the same way.
The problem arises in short key mode on .NET, since 128 bits is only two 64 bit DES keys
The algorithm that they use then is:

Encrypt Key1 -> Decrypt Key2 -> Encrypt Key1

mcrypt does not have this mode of operation natively.
but before you go and start running DES three times yourself, here's a Quick Fix
= "12345678abcdefgh"; // a 128 bit (16 byte) key
$my_key .= substr($my_key,0,8); // append the first 8 bytes onto the end
$secret = mcrypt_encrypt(MCRYPT_3DES, $my_key, $data, MCRYPT_MODE_CBC, $iv);  //CBC is the default mode in .NET

And, like magic, it works.

There's one more caveat: Data padding
mcrypt always pads data will the null character
but .NET has two padding modes: "Zeros" and "PKCS7"
Zeros is identical to the mcrypt scheme, but PKCS7 is the default.
PKCS7 isn't much more complex, though:
instead of nulls, it appends the total number of padding bytes (which means, for 3DES, it can be a value from 0x01 to 0x07)
if your plaintext is "ABC", it will be padded into:
0x41 0x42 0x43 0x05 0x05 0x05 0x05 0x05

You can remove these from a decrypted string in PHP by counting the number of times that last character appears, and if it matches it's ordinal value, truncating the string by that many characters:
= mcrypt_get_block_size('tripledes', 'cbc');
$packing = ord($text{strlen($text) - 1});
$packing and ($packing < $block)){
$P = strlen($text) - 1; $P >= strlen($text) - $packing; $P--){
ord($text{$P}) != $packing){
$packing = 0;
$text = substr($text,0,strlen($text) - $packing);

And to pad a string that you intend to decrypt with .NET, just add the chr() value of the number of padding bytes:
= mcrypt_get_block_size('tripledes', 'cbc');
$len = strlen($dat);
$padding = $block - ($len % $block);
$dat .= str_repeat(chr($padding),$padding);

That's all there is to it.
Knowing this, you can encrypt, decrypt, and duplicate exactly any .NET 3DES behaviour in PHP.
7 years ago
I should mention that ECB mode ignores the IV, so it is misleading to show an example using both MCRYPT_MODE_ECB and an IV (the example in the manual shows the same thing).  Also, it's important to know that ECB is useful for random data, but structured data should use a stronger mode like MCRYPT_MODE_CBC

Also, rtrim($decryptedtext, "\0") would be a better option to remove NULL padding than my lazy trim()...
Robin Leffmann
4 years ago
Contrary to what is implied in the mcrypt_encrypt() manual page, as well as the info given regarding the CBC vs CFB modes, mcrypt_encrypt() works just fine for encrypting binary data as well.

A simple example verifies that the decrypted output is binary identical once cut to its original length:


// 448-bit key (56 bytes) - the only size that mcrypt/php uses for the Blowfish cipher
// (using a smaller key works just fine, as mcrypt appends \0 to reach proper key-size)
$key = 'SADFo92jzVnzSj39IUYGvi6eL8v6RvJH8Cytuiouh547vCytdyUFl76R';

// Blowfish/CBC uses an 8-byte IV
$iv = substr( md5(mt_rand(),true), 0, 8 );

// do 50 encrypt/decrypt operations on some random data, and verify integrity with md5()
for( $i = 0; $i < 50; $i++ )
// create a random, binary string of random length
$size = mt_rand( 25000, 500000 );
$c = 0; $data = null;
$c++ * 16 < $size )
$data .= md5( mt_rand(), true );
$data = substr( $data, 0, $size );
$cksum = md5( $data );

// encrypt using Blowfish/CBC
$enc = mcrypt_encrypt( MCRYPT_BLOWFISH, $key, $data, MCRYPT_MODE_CBC, $iv );

$size . ' -> ' . strlen( $enc ) . ' -> ';

// decrypt (using same IV - a must for the CBC mode)
$dec = mcrypt_decrypt( MCRYPT_BLOWFISH, $key, $enc, MCRYPT_MODE_CBC, $iv );

// cut the output with substr(), NOT by using rtrim() as is suggested in some of
    // the mcrypt manual pages - this is binary data, not plaintext
echo ( md5(substr($dec, 0, $size)) == $cksum ? 'ok' : 'bad' ) . PHP_EOL;

3 years ago
I've noticed some people using a-z, A-Z and 0-9 for keys and stating things like "16 characters is a 128-bit key". This isn't true. Using only these characters, you will get at most 6 bits of entropy per chartacter:

log2(26 + 26 + 10) = 5.954196310386876

So you're actually only getting 95 bits of entropy in 16 characters, which is 0.0000000117% of the keyspace you would get if you were using the full range.

In order to get the full entropy from a key using just a-z, A-Z and 0-9 you should multiply your key length by 1.3333 to account for the 2 bits of lost entropy per byte.
1 year ago
Note that the IV must be the same for mcrypt_encrypt and mcrypt_decrypt, otherwise you will have corrupted data after decryption.
gm dot outside+php at gmail dot com
2 months ago
Please note that the following part of the documentation is no longer true (after commit:;a=commit;h=a861a3a93d89a50ce58e1ab1abef1eb501f97483):

> key
> The key with which the data will be encrypted. If it's smaller than the required keysize, it is padded with '\0'. It is better not to use ASCII strings for keys.

That commit changed the behaviour to be strict and if the keysize is smaller than the required size a warning will be issued as follows:

Warning: mcrypt_encrypt(): Key of size 10 not supported by this algorithm. Only keys of size 16 supported in script.php on line 5

and the mcrypt_encode() will return failure.
stefan at katic dot me dot rs
11 months ago
I was trying (and succeeded) to encrypt and decrypt in JAVA, pass it to php, and do it again,without corrupting data when I noticed something interesting. So, my code goes like this:
$data = 'one';
$key = '1234567890123456';

function encrypt($data, $key){
    return base64_encode(
function decrypt($data, $key){
    $decode = base64_decode($data);
    return mcrypt_decrypt(
$encrypted = encrypt($data, $key);
$decrypted= decrypt($encrypted, $key);

//In the beginning, I thought something's wrong, because I did '===' comparison between $decrypted and $data. It didn't work (but later started working, again, dont know why...) So, I dumped both:
string(16) "one"
string(16) "one"
//Clearly, the length of both is 3, not 16. Just wanted to let you know what could happen, and I really don't know if this is a bug...
stonecypher at gmail dot com
8 years ago
Most of the user-written cipher examples here are badly broken, and there are a few cases where the manual says things that are outright incorrect, such as that it's "safe to transmit the initialization vector in plaintext" (this is incorrect: see Ciphers By Ritter, ,  for details.)

mcrypt itself is perfectly safe, but correct and therefore safe usage is inobvious.  It is important to use a cryptographic library correctly; a simple usage error, even when it produces results that can be unpacked at the other side, can render a strong algorithm completely useless.

The initialization vector must be permuted with a recoverable noise source (an arbitrary md5 hash is acceptable, since it's just a fake OTP and its origin contents are wholly unimportant.)

Passwords should be remade with a salted one-way hash (md5 is again acceptable even though it's been damaged, since the only thing you could recover from a cracked md5 hash is the source data to generate the password, which is useless.)

It's important to use a sane block mode (OFB is unsafe for almost all algorithms; never use it.  Prefer CBC in all cases except where you need to deal with a degraded signal and cannot retransmit.)

A correct usage example is actually pretty long and needs a lot of explanation, so I developed a safe wrapper library which doesn't constrain usage and which comments itself very heavily.  It's appropriate for use or for learning.  Please see my blog for details on Stone PHP SafeCrypt:
ale_ferrer at yahoo dot com
8 years ago
Mcript - Dot NET - 3DES problem.

This is a solution for the 3DES algorithm's problem in his interaction with .NET TripleDESCryptoServiceProvider (System.Security.Cryptography), CBC mode,  because the key is completed to 192bits and the text is padded.

So, we has two problems:
           - The key's completion  was posted by "jesse at pctest dot com".
           - The text padding also posted by him, but the completion is a little different. The padding bytes are 0x01 to 0x08 because completed to 8 bytes blocks. If your text have a whole number of 8 bytes blocks, the algorithm add other block with padded bytes (0x08).

This is a function to encrypt a text in a equal form that the Dot NET algorithm:

function encryptNET3DES($key, $vector, $text){
$td = mcrypt_module_open (MCRYPT_3DES, '', MCRYPT_MODE_CBC, '');

// Complete the key
$key_add = 24-strlen($key);
$key .= substr($key,0,$key_add);

// Padding the text
$text_add = strlen($text)%8;
$i=$text_add; $i<8; $i++){
$text .= chr(8-$text_add);

mcrypt_generic_init ($td, $key, $vector);
$encrypt64 = mcrypt_generic ($td, $text);

// Return the encrypt text in 64 bits code
return $encrypt64;
To Top