Skip to main content

Insecure encryption algorithm


Implementation of secure encryption algorithms


  • Usage of Python 3 for building and running Python applications
  • Usage of Crypto for cryptographic operations
  • Usage of base64 for encoding and decoding data in base64 format


Non compliant code

from Crypto.Cipher import DES
import base64

def encrypt(input_string):
key = b'abcdefgh' # 8 bytes key
des =, DES.MODE_ECB)
padded_text = pad(input_string)
encrypted_text = des.encrypt(padded_text)
return base64.b64encode(encrypted_text).decode('utf-8')

def decrypt(input_string):
key = b'abcdefgh' # 8 bytes key
des =, DES.MODE_ECB)
decrypted_text = des.decrypt(base64.b64decode(input_string))
return decrypted_text

The above code is using the DES (Data Encryption Standard) algorithm for encryption and decryption. The DES algorithm is considered insecure because it uses a relatively small key size (56-bits), which can be broken with modern computational power. Additionally, the code is using ECB (Electronic Code Book) mode, which is the simplest form of block cipher encryption but is also the least secure. This mode does not provide serious message confidentiality, as identical plaintext blocks are encrypted into identical ciphertext blocks. Thus, it does not hide data patterns well. In some senses, it doesn't provide serious message confidentiality, and it is not recommended for use in cryptographic protocols at all.


  • Replace the DES encryption algorithm with a more secure one, such as AES-256.
  • Ensure that the encryption key is securely generated and stored. Avoid hardcoding the key in the code.
  • Use a secure mode of operation, such as Cipher Block Chaining (CBC) or Galois/Counter Mode (GCM), instead of Electronic Codebook (ECB) mode.
  • Consider using a library that provides higher-level encryption functionalities, such as PyNaCl or, to avoid common cryptographic pitfalls.

Compliant code

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad
import base64

def encrypt(input_string):
key = get_random_bytes(32) # 32 bytes key for AES-256
cipher =, AES.MODE_CBC)
padded_text = pad(input_string.encode(), AES.block_size)
encrypted_text = cipher.encrypt(padded_text)
return base64.b64encode(cipher.iv + encrypted_text).decode('utf-8')

def decrypt(input_string):
raw = base64.b64decode(input_string)
iv = raw[:AES.block_size]
key = get_random_bytes(32) # 32 bytes key for AES-256
cipher =, AES.MODE_CBC, iv=iv)
decrypted_text = unpad(cipher.decrypt(raw[AES.block_size:]), AES.block_size)
return decrypted_text.decode()

The original code was using the DES encryption algorithm, which is considered insecure due to its small key size. The new code uses the AES-256 encryption algorithm, which is currently considered secure.

The key for the encryption algorithm is now generated using the get_random_bytes function from the Crypto.Random module, which generates a secure random key. This is an improvement over the hardcoded key in the original code.

The mode of operation has been changed from ECB to CBC. ECB mode is insecure because it does not provide serious message confidentiality, while CBC mode does.

The pad and unpad functions from the Crypto.Util.Padding module are used to handle padding of the input data. This is necessary because AES is a block cipher and requires the input length to be a multiple of the block size.

The encrypted text and the initialization vector (IV) are concatenated and then base64 encoded before being returned by the encrypt function. The decrypt function base64 decodes the input string, then extracts the IV and the encrypted text, and finally decrypts the text.

Please note that the key used in the decrypt function should be the same as the one used in the encrypt function. In a real-world scenario, you would need to securely store and retrieve this key.