Skip to main content

Insecure generation of random numbers - Static IV

Need​

Secure generation of random numbers and dynamic initialization vectors

Context​

  • Usage of PHP 7.1 for server-side scripting and web development
  • Usage of OpenSSL for secure communication and encryption

Description​

Non compliant code​

<?php
    $cipherMethod = 'AES-256-CBC';
    $key = 'ThisIsASecretKey';
    $iv = '1234567890123456'; // This is a static, hardcoded initialization vector

    function encryptData($data) {
        global $cipherMethod, $key, $iv;
        $encryptedData = openssl_encrypt($data, $cipherMethod, $key, OPENSSL_RAW_DATA, $iv);
        return $encryptedData;
    }

    function decryptData($encryptedData) {
        global $cipherMethod, $key, $iv;
        $decryptedData = openssl_decrypt($encryptedData, $cipherMethod, $key, OPENSSL_RAW_DATA, $iv);
        return $decryptedData;
    }
?>

The vulnerable code above is a simple PHP script that encrypts and decrypts data using the AES-128-CBC encryption method. The problem lies in the static, hardcoded initialization vector ($iv) used for the encryption and decryption process.

An initialization vector (IV) is an arbitrary number that can be used along with a secret key for data encryption. This number, also called a nonce, is used to randomize the encryption and hence to produce distinct ciphertexts even if the plaintexts are the same, which is a desirable property for encryption schemes.

In this code, the IV is hardcoded and static, which means it doesn't change across different sessions or users. This is a security vulnerability because if an attacker can guess or know the IV, they could potentially reverse engineer the encryption process and decrypt the data, even without knowing the secret key.

In addition, because the IV is static, the same plaintext will always result in the same ciphertext, making the encryption deterministic instead of probabilistic. This could potentially allow an attacker to infer patterns in the encrypted data, further increasing the risk of a successful attack.

Steps​

  • Replace the static, hardcoded initialization vector (IV) with a dynamically generated one.
  • Use the openssl_random_pseudo_bytes function to generate a random IV for each encryption process.
  • Ensure the length of the IV matches the block size of the cipher method being used.
  • Store the IV along with the encrypted data, so it can be used for decryption. The IV doesn't need to be kept secret, but it should be different for each encryption process.
  • During decryption, retrieve the IV from the stored data and use it to decrypt the data.

Compliant code​

<?php
    $cipherMethod = 'AES-256-CBC';
    $key = 'ThisIsASecretKey';

    function encryptData($data) {
        global $cipherMethod, $key;
        $iv = openssl_random_pseudo_bytes(openssl_cipher_iv_length($cipherMethod)); // Generate a random IV
        $encryptedData = openssl_encrypt($data, $cipherMethod, $key, OPENSSL_RAW_DATA, $iv);
        return base64_encode($encryptedData . '::' . $iv); // Store the IV along with the encrypted data
    }

    function decryptData($encryptedData) {
        global $cipherMethod, $key;
        list($encryptedData, $iv) = explode('::', base64_decode($encryptedData), 2); // Retrieve the IV from the stored data
        $decryptedData = openssl_decrypt($encryptedData, $cipherMethod, $key, OPENSSL_RAW_DATA, $iv);
        return $decryptedData;
    }
?>

The updated code now generates a random Initialization Vector (IV) for each encryption process using the openssl_random_pseudo_bytes function. The length of the IV is determined by the block size of the cipher method being used, which is obtained using the openssl_cipher_iv_length function.

The IV is then used to encrypt the data, and it is stored along with the encrypted data. The IV and the encrypted data are concatenated with a '::' separator and then base64 encoded to ensure that the data can be safely stored and transmitted.

During the decryption process, the base64 encoded data is decoded and the IV and the encrypted data are separated using the '::' separator. The IV is then used to decrypt the data.

This approach ensures that a unique IV is used for each encryption process, which significantly increases the security of the encryption. The IV does not need to be kept secret, but it should be different for each encryption process to prevent attackers from being able to predict the random values.

References​

Last updated on