Weak Encryption: Insecure Initialization Vector

Initialization vectors should be created using a cryptographic pseudorandom number generator.

Initialization vectors (IVs) should be created using a cryptographic pseudorandom number generator. Without using a random IV, the resulting ciphertext becomes much more predictable and susceptible to a dictionary attack.

Example 1: The following code performs AES encryption using a non-random IV:

...
Blob iv = Blob.valueOf('1234567890123456');
Blob encrypted = Crypto.encrypt('AES128', encKey, iv, input);
...

Initialization vectors should be created using a cryptographic pseudorandom number generator.

Initialization vectors (IVs) should be created using a cryptographic pseudorandom number generator. Not using a random IV makes the resulting ciphertext much more predictable and susceptible to a dictionary attack.

Example 1: The following code creates an non-random IV using hardcoded bytes.

byte[] iv = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
using (SymmetricAlgorithm aesAlgo = SymmetricAlgorithm.Create("AES"))
{
    ...
    aesAlgo.IV = iv;
    ...
}

Initialization vectors should be created using a cryptographic pseudorandom number generator.

Initialization vectors (IVs) should be created using a cryptographic pseudorandom number generator. Not using a random IV makes the resulting ciphertext much more predictable and susceptible to a dictionary attack.

Example 1: The following code creates a non-random IV using a hardcoded string.

unsigned char * iv = "12345678";
EVP_EncryptInit_ex(&ctx, EVP_idea_gcm(), NULL, key, iv);

Use a cryptographic pseudorandom number generator to create initialization vectors.

Use a cryptographic pseudorandom number generator to create initialization vectors (IVs). Otherwise, the resulting ciphertext is more predictable and susceptible to a dictionary attack.

Example 1: The following code reuses the key as the IV:

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
)
...
block, err := aes.NewCipher(key)
...
mode := cipher.NewCBCEncrypter(block, key)
mode.CryptBlocks(ciphertext[aes.BlockSize:], plaintext)

If you use the key as the IV, attackers can recover the key, which enables them to decrypt the data.

An insecure initialization vector (IV) makes the ciphertext susceptible to dictionary attacks.

Create initialization vectors (IVs) using a cryptographic pseudorandom number generator. Failure to use a random IV makes the resulting ciphertext much more predictable and susceptible to dictionary attacks.

Example 1: The following code creates a non-random IV using a hardcoded string.

...
const iv = "hardcoded"
const cipher = crypto.createCipheriv("aes-192-ccm", key, iv)

Initialization vectors should be created using a cryptographic pseudorandom number generator.

Initialization vectors (IVs) should be created using a cryptographic pseudorandom number generator. Not using a random IV makes the resulting ciphertext much more predictable and susceptible to a dictionary attack.

Example 1: The following code creates a non-random IV using hardcoded bytes.

...
NSString *iv = @"1234567812345678";  //Bad idea to hard code IV
char ivPtr[kCCBlockSizeAES128];

[iv getCString:ivPtr maxLength:sizeof(ivPtr) encoding:NSASCIIStringEncoding];
...
ccStatus = CCCrypt(   kCCEncrypt,
                      kCCAlgorithmAES128,
                      kCCOptionPKCS7Padding,
                      [key cStringUsingEncoding:NSASCIIStringEncoding],
                      kCCKeySizeAES128,
                      [ivPtr], /*IV should be something random (not null and not constant)*/
                      [self bytes], dataLength, /* input */
                      buffer, bufferSize, /* output */
                      &numBytesEncrypted
                  );

In addition, if CBC mode is selected when calling CCCrypt and no IV is provided (nil) then an IV of all zeros will be used.

Initialization vectors should be created using a cryptographic pseudorandom number generator.

Initialization vectors (IVs) should be created using a cryptographic pseudorandom number generator. Not using a random IV makes the resulting ciphertext much more predictable and susceptible to a dictionary attack.

Example 1: The following code reuses the key as the IV:

from Crypto.Cipher import AES
from Crypto import Random
...
key = Random.new().read(AES.block_size)
cipher = AES.new(key, AES.MODE_CTR, IV=key)

When you use the key as the IV, an attacker may recover the key, allowing the data to be decrypted.

Initialization vectors should be created using a cryptographic pseudorandom number generator.

Initialization vectors (IVs) should be created using a cryptographic pseudorandom number generator. Not using a random IV makes the resulting ciphertext much more predictable and susceptible to a dictionary attack.

Example 1: The following code reuses the key as the IV:

require 'openssl'
...
cipher = OpenSSL::Cipher::AES.new('256-GCM')
cipher.encrypt
@key = cipher.random_key
cipher.iv=@key

encrypted = cipher.update(data) + cipher.final # encrypts data without hardcoded IV
...

When you use the key as the IV, an attacker may recover the key, allowing the data to be decrypted.

Initialization vectors should be created using a cryptographic pseudorandom number generator.

Initialization vectors (IVs) should be created using a cryptographic pseudorandom number generator. Not using a random IV makes the resulting ciphertext much more predictable and susceptible to a dictionary attack.

Example 1: The following code creates a non-random IV using hardcoded bytes.

...
let cStatus = CCCrypt(UInt32(kCCEncrypt),
UInt32(kCCAlgorithmAES128),
UInt32(kCCOptionPKCS7Padding),
key,
keyLength,
"0123456789012345", 
plaintext, 
plaintextLength,
ciphertext, 
ciphertextLength,
&numBytesEncrypted)

In addition, if CBC mode is selected when calling CCCrypt and no IV is provided (nil) then an IV of all zeros will be used.