Skip to main content

Insecure generation of random numbers - Static IV

Need​

Secure generation of random numbers and dynamic initialization vectors

Context​

  • Usage of Ruby for building dynamic and object-oriented applications
  • Usage of OpenSSL for secure communication and encryption

Description​

Non compliant code​

require 'openssl'

KEY = 'a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6'
IV = 'a1b2c3d4e5f6g7h8'

def encrypt(data)
  cipher = OpenSSL::Cipher::AES.new(128, :CBC)
  cipher.encrypt
  cipher.key = KEY
  cipher.iv = IV  # static initialization vector
  cipher.update(data) + cipher.final
end

In the above code, the encrypt function is used to encrypt data using the AES (Advanced Encryption Standard) algorithm in CBC (Cipher Block Chaining) mode. The KEY and IV (Initialization Vector) are hardcoded and static which is a security vulnerability.

The Initialization Vector (IV) is supposed to be random and unique for each encryption operation. It is used to ensure that the encryption of each block of plaintext is unique, even if the same plaintext and key are used. By using a static, hardcoded IV, the same plaintext will always be encrypted to the same ciphertext. This makes the encryption predictable and susceptible to certain types of attacks.

An attacker, knowing the IV and having multiple ciphertexts, could perform cryptographic analysis to predict the encryption of other plaintexts, or even deduce the key. This is particularly problematic if the key is used for multiple encryption operations. The use of a static IV also enables replay attacks, where an attacker can replay a previously captured message to cause the application to perform an action.

In conclusion, the use of a static, hardcoded IV in the encrypt function makes the encryption predictable and weakens the security of the application.

Steps​

  • Generate a random and unique initialization vector (IV) for each encryption operation.
  • Use a secure random number generator to generate the IV.
  • Ensure that the IV is securely stored and not hardcoded in the code.
  • Update the code to use the generated IV instead of the static IV.
  • Ensure that the IV is passed along with the encrypted data to the decryption process.

Compliant code​

require 'openssl'

KEY = 'a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6'

def encrypt(data)
  cipher = OpenSSL::Cipher::AES.new(128, :CBC)
  cipher.encrypt
  cipher.key = KEY
  cipher.iv = OpenSSL::Random.random_bytes(16) # dynamic initialization vector
  encrypted = cipher.update(data) + cipher.final
  { iv: cipher.iv, data: encrypted } # return both IV and encrypted data
end

The updated code now generates a random and unique Initialization Vector (IV) for each encryption operation. This is done using the OpenSSL::Random.random_bytes(16) method, which generates a secure random number. This number is then used as the IV for the encryption process.

The IV is no longer hardcoded in the code, which eliminates the risk of an attacker being able to predict the random values that should remain secret.

The encrypt method now returns a hash containing both the IV and the encrypted data. This is necessary because the IV must be known for the decryption process. By returning it along with the encrypted data, we ensure that it is available for decryption, but without exposing it in the code.

This approach significantly improves the security of the encryption process by ensuring that each encryption operation uses a unique, unpredictable IV.

References​

Last updated on