Skip to main content

Insecure encryption algorithm - TripleDES


Implementation of secure encryption algorithms and modes


  • Usage of Scala for building scalable and high-performance applications
  • Usage of javax.crypto for cryptographic operations in Java


Non compliant code

import javax.crypto.spec.SecretKeySpec
import javax.crypto.Cipher
import javax.crypto.spec.IvParameterSpec

val secret: String = "ThisIsASecretKey"
val cipher: Cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding")
val key: SecretKeySpec = new SecretKeySpec(secret.getBytes, "DESede")

cipher.init(Cipher.ENCRYPT_MODE, key)

val plainText: String = "Sensitive Information"
val cipherText: Array[Byte] = cipher.doFinal(plainText.getBytes)

The above Scala code is used to encrypt sensitive data using the Triple DES (3DES) encryption algorithm in ECB mode. Here's a breakdown of what the code does:

  • Cipher.getInstance("DESede/ECB/PKCS5Padding") : This line is initializing a Cipher instance with Triple DES encryption in ECB mode with PKCS5 Padding.
  • new SecretKeySpec(secret.getBytes, "DESede") : This line is creating a key to be used for encryption using the provided secret.
  • cipher.init(Cipher.ENCRYPT_MODE, key) : This line is initializing the Cipher instance to encryption mode using the created key.
  • cipher.doFinal(plainText.getBytes) : This line is encrypting the plaintext using the initialized cipher.

This code is considered vulnerable because it uses the DESede (Triple DES) encryption algorithm in ECB mode. ECB (Electronic Code Book) mode is considered insecure for any block cipher because it does not use an Initialization Vector (IV) and therefore the same block of plaintext will always encrypt to the same block of ciphertext, making it vulnerable to pattern attacks.

Further, DESede itself is considered weak due to its small key size and is not recommended for use in any new systems. The small key size makes it susceptible to brute-force attacks.

In secure applications, it is recommended to use more secure encryption algorithms such as AES with a secure mode like CBC or GCM, and also ensure to use a secure random Initialization Vector (IV) for each encryption.


  • Replace the insecure encryption algorithm TripleDES with a more secure algorithm, such as AES.
  • Use a secure mode of operation, such as CBC (Cipher Block Chaining), instead of ECB (Electronic Codebook).
  • Generate a secure and random encryption key.
  • Ensure the encryption key is securely stored and not hardcoded in the code.
  • Use a secure padding scheme, such as PKCS7Padding, instead of PKCS5Padding.

Compliant code

import javax.crypto.Cipher
import javax.crypto.spec.IvParameterSpec
import javax.crypto.spec.SecretKeySpec
import java.util.Base64

val random = new SecureRandom()
val secretKey = new Array[Byte](16)

val cipher: Cipher = Cipher.getInstance("AES/CBC/PKCS7Padding")
val key: SecretKeySpec = new SecretKeySpec(secretKey, "AES")

val iv = new Array[Byte](cipher.getBlockSize)
val ivParams = new IvParameterSpec(iv)

cipher.init(Cipher.ENCRYPT_MODE, key, ivParams)

val plainText: String = "Sensitive Information"
val cipherText: Array[Byte] = cipher.doFinal(plainText.getBytes)

val encryptedText = Base64.getEncoder.encodeToString(cipherText)

The above code fixes the vulnerability by replacing the insecure encryption algorithm TripleDES with a more secure algorithm, AES.

The mode of operation is changed from ECB (Electronic Codebook) to CBC (Cipher Block Chaining). CBC mode is more secure because it introduces feedback. Each block of plaintext is XORed with the previous ciphertext block before being encrypted. This way, each ciphertext block depends on all plaintext blocks processed up to that point.

A secure and random encryption key is generated using SecureRandom. This is more secure than hardcoding the key in the code, as was done previously.

The padding scheme is changed from PKCS5Padding to PKCS7Padding. PKCS7Padding is more secure because it can provide a padding length from 1 up to 256, while PKCS5Padding only provides a padding length of 8.

The encrypted text is then encoded to a string using Base64 encoding. This is done to ensure that the encrypted text can be safely transmitted or stored, as it only uses printable ASCII characters.