Skip to main content

Insecure encryption algorithm - Cipher Block Chaining


Implementation of secure encryption algorithms with strong cipher block chaining.


  • Requirement of PHP 5.3.0 or later for running the application
  • Usage of OpenSSL for secure communication and encryption


Non compliant code

$method = 'AES-128-CBC';
$iv = '1234567890123456'; // 16 bytes
$key = 'abcdefghijklmnop'; // 16 bytes
$plaintext = 'Sensitive Information';

$ciphertext = openssl_encrypt($plaintext, $method, $key, OPENSSL_RAW_DATA, $iv);
echo base64_encode($ciphertext);

The above PHP code is an example of using an insecure encryption algorithm - Cipher Block Chaining (CBC).

In this code, the AES-128-CBC encryption algorithm is used, which is a block cipher mode that can encrypt data in fixed-size blocks. The openssl_encrypt function is used to encrypt the plaintext 'Sensitive Information' using the AES-128-CBC algorithm.

The key and initialization vector (IV) are both 16 bytes long, which is the block size of AES. The IV is a random value that is required to start off the encryption process and must be unique for each encryption.

The vulnerability lies in the use of Cipher Block Chaining (CBC). In CBC mode, each block of plaintext is XORed with the previous ciphertext block before being encrypted. This means that an attacker can manipulate the ciphertext blocks to cause predictable changes in the decrypted plaintext, leading to a potential breach of data confidentiality.

Moreover, the IV in this code is hardcoded which is a bad practice. The IV should be random and unique for each encryption to ensure the security of the encryption process. If the same IV is used for all encryptions, it can lead to the exposure of patterns in the encrypted data, making it easier for attackers to crack the encryption.

The key is also hardcoded which is another bad practice. The key should be securely generated and stored and should not be hardcoded in the application code.

Therefore, the use of an insecure encryption algorithm and the inappropriate handling of the key and IV make this code vulnerable to attacks.


  • Replace the insecure AES-128-CBC algorithm with a more secure one such as AES-256-GCM.
  • Ensure that the initialization vector (IV) is unique and random for each encryption operation. Do not hardcode it.
  • Use a secure method to generate and store the encryption key. Do not hardcode it.
  • Consider using a library or module that provides higher-level encryption methods, to avoid potential mistakes in implementing lower-level cryptographic operations.

Compliant code

$method = 'aes-256-gcm';
$plaintext = 'Sensitive Information';

// Generate a 16-byte random IV
$ivlen = openssl_cipher_iv_length($method);
$iv = openssl_random_pseudo_bytes($ivlen);

// Generate a 256-bit random key
$key = openssl_random_pseudo_bytes(32);

$ciphertext = openssl_encrypt($plaintext, $method, $key, $options=0, $iv, $tag);

echo base64_encode($ciphertext);

The original code was using an insecure encryption algorithm (AES-128-CBC) and hardcoding the initialization vector (IV) and the encryption key. This is insecure because the IV should be unique and random for each encryption operation, and the encryption key should be securely generated and stored, not hardcoded.

The fixed code uses a more secure encryption algorithm (AES-256-GCM). It generates a random IV of the appropriate length for this algorithm using the openssl_cipher_iv_length and openssl_random_pseudo_bytes functions. It also generates a random 256-bit key using openssl_random_pseudo_bytes.

The openssl_encrypt function is then called with these secure parameters, and the resulting ciphertext is base64-encoded and printed.

This code is more secure because it uses a stronger encryption algorithm and properly generates and uses a unique, random IV and key for each encryption operation.