Skip to main content

Insecure encryption algorithm - Cipher Block Chaining

Need​

Implementation of secure encryption algorithms with strong cipher block chaining

Context​

  • Usage of Dart 2.0 for building fast and efficient web and mobile applications
  • Usage of cipher for encryption and decryption operations

Description​

Non compliant code​

import 'dart:convert';
import 'dart:typed_data';
import 'package:cipher/cipher.dart';
import 'package:cipher/impl/base.dart';

void main() {
  final key = utf8.encode('my secure key');
  final iv = Uint8List(8);
  final plaintext = 'Hello, world!';

  final encrypter = new PaddedBlockCipher('AES/CBC/PKCS7')
    ..init(true, new PaddedBlockCipherParameters<Null, KeyParameter>(null, new KeyParameter(key)));

  final ciphertext = encrypter.process(utf8.encode(plaintext));

  print('Ciphertext: ${base64.encode(ciphertext)}');
}

The above Dart code is a simple implementation of the AES encryption algorithm in Cipher Block Chaining (CBC) mode.

The main function initializes a key and an initialization vector (IV), as well as the plaintext message to be encrypted. It then creates a new PaddedBlockCipher object, specifying AES/CBC/PKCS7 as the cipher to be used. The cipher is initialized with the key and IV, and the plaintext message is encrypted.

The problem lies in the use of the Cipher Block Chaining (CBC) mode. CBC mode is considered insecure for many applications because it is vulnerable to a variety of cryptographic attacks, such as the BEAST attack and Padding Oracle attacks.

In addition, the initialization vector (IV) in this code is a fixed value, which is also a major security risk. The IV should be random and unique for each encryption operation to ensure the security of the encryption algorithm.

Lastly, the key is hardcoded into the application, which is a bad practice. The key should be stored securely and not directly in the application code.

Steps​

  • Replace the insecure Cipher Block Chaining (CBC) mode with a more secure mode such as Galois/Counter Mode (GCM).
  • Ensure that the Initialization Vector (IV) is unique and random for each encryption operation.
  • Use a secure method to generate and store the encryption key, avoid hardcoding the key in the code.
  • Ensure that the key length is sufficient, for AES encryption a key length of 128, 192 or 256 bits is recommended.
  • Use a secure padding scheme, PKCS7 is secure and commonly used.

Compliant code​

import 'dart:convert';
import 'dart:typed_data';
import 'package:cipher/cipher.dart';
import 'package:cipher/impl/base.dart';
import 'package:pointycastle/export.dart';

void main() {
  final secureRandom = FortunaRandom();
  final secureKey = secureRandom.nextBytes(32); // Generate a 256-bit key
  final iv = secureRandom.nextBytes(16); // Generate a 128-bit IV
  final plaintext = 'Hello, world!';

  final gcm = new GCMBlockCipher(AESFastEngine())
    ..init(true, AEADParameters(KeyParameter(secureKey), 128, iv));

  final ciphertext = gcm.process(utf8.encode(plaintext));

  print('Ciphertext: ${base64.encode(ciphertext)}');
}

The original code was using an insecure Cipher Block Chaining (CBC) mode for encryption. This mode is vulnerable to certain types of attacks, such as the bit-flipping attack. The code was also using a hardcoded key, which is not secure because it can be easily discovered by an attacker.

The updated code uses the Galois/Counter Mode (GCM), which is a more secure mode of operation for symmetric key cryptographic block ciphers. It also uses a secure random number generator to generate the encryption key and the Initialization Vector (IV). The key and the IV are unique and random for each encryption operation, which increases the security of the encryption.

The key length is 256 bits, which is a recommended length for AES encryption. The IV length is 128 bits, which is the block size of AES.

The code uses the Pointy Castle library, which is a Dart implementation of the Java cryptography library Bouncy Castle. It provides a wide range of cryptographic algorithms, including secure random number generators, symmetric and asymmetric ciphers, and secure padding schemes.

References​

Last updated on