Encrypting and Decrypting with python and nodejs

while trying to run the Python script using Python 3.8 I encountered the following error:

  m.update(password) 
  TypeError: Unicode-objects must be encoded before hashing

the password should be :

  password = b'abcd'

I also got the following error :

m.update(password + key) 
TypeError: can't concat str to bytes

I was able to fix it by adding the following line after key:

    key = bytes.fromhex(key_)

The python script should work this way :

from Crypto.Cipher import AES
from hashlib import md5
import base64


password = b'abcd'
input = 'hello world'

BLOCK_SIZE = 16

def pad (data):
    pad = BLOCK_SIZE - len(data) % BLOCK_SIZE
    return data + pad * chr(pad)

def unpad (padded):
    pad = ord(chr(padded[-1]))
    return padded[:-pad]

def _encrypt(data, nonce, password):
    m = md5()
    m.update(password)
    key_ = m.hexdigest()
    key = bytes.fromhex(key_)

    m = md5()
    m.update(password + key)
    iv = m.hexdigest()
    iv = bytes.fromhex(iv)

    data = pad(data)

    aes = AES.new(key, AES.MODE_CBC, iv[:16])

    encrypted = aes.encrypt(data.encode('utf-8'))
    return base64.urlsafe_b64encode(encrypted)

def _decrypt(edata, nonce, password):
    edata = base64.urlsafe_b64decode(edata)

    m = md5()
    m.update(password)
    key = m.hexdigest()
    key = bytes.fromhex(key)

    m = md5()
    m.update(password + key)
    iv = m.hexdigest()
    iv = bytes.fromhex(iv)

    aes = AES.new(key, AES.MODE_CBC, iv[:16])
    return unpad(aes.decrypt(edata))

output = _encrypt(input, "", password) 
print(output)
plaintext = _decrypt(output, "", password)
print(plaintext)

Because I spent way too much time on this with Python 3.10.7 and Node.js v18.6.0.

Here is a working code totally compatible between two languages with examples.

Only the secret is needed for getting same values as expected :)

Note pycryptodome is needed for Python. Code should be tweaked for supporting different algorithms.

const crypto = require('crypto')

function get_crypto(secret, encode) {
  // Create hashed key from password/key
  let m = crypto.createHash('md5').update(secret)
  const key = m.digest('hex')
  m = crypto.createHash('md5').update(secret + key)
  const iv = m.digest('hex').slice(0, 16) // only in aes-256

  return encode
    ? crypto.createCipheriv('aes-256-cbc', key, iv)
    : crypto.createDecipheriv('aes-256-cbc', key, iv)
}

const secret = 'f8abb29f13cb932704badb0de414ab08ca9f6c63' // crypto.randomBytes(20).toString('hex')

const value = 'hello world'
const data = Buffer.from(value, 'utf8').toString('binary')
const cipher = get_crypto(secret, true)
const encrypted = Buffer.concat([cipher.update(data, 'utf8'), cipher.final()]).toString('binary')
const encoded = Buffer.from(encrypted, 'binary').toString('base64')
console.log('encoded:', encoded)

const edata = Buffer.from(encoded, 'base64').toString('binary')
const decipher = get_crypto(secret, false)
const decoded = Buffer.concat([decipher.update(edata, 'binary'), decipher.final()]).toString('utf-8')
console.log('decoded:', decoded)

# This script needs pycryptodome dependency
# pip install pycryptodome

from Crypto.Cipher import AES
from hashlib import md5
import base64

BLOCK_SIZE = AES.block_size


def get_aes(s):
    m = md5()
    m.update(s.encode('utf-8'))
    key = m.hexdigest()
    m = md5()
    m.update((s + key).encode('utf-8'))
    iv = m.hexdigest()

    return AES.new(key.encode("utf8"), AES.MODE_CBC, iv.encode("utf8")[:BLOCK_SIZE])


# pkcs5 padding
def pad(byte_array):
    pad_len = BLOCK_SIZE - len(byte_array) % BLOCK_SIZE
    return byte_array + (bytes([pad_len]) * pad_len)


# pkcs5 - unpadding
def unpad(byte_array):
    return byte_array[:-ord(byte_array[-1:])]


def _encrypt(s, data):
    data = pad(data.encode("UTF-8"))
    aes = get_aes(s)
    encrypted = aes.encrypt(data)
    return base64.urlsafe_b64encode(encrypted).decode('utf-8')


def _decrypt(s, edata):
    edata = base64.urlsafe_b64decode(edata)
    aes = get_aes(s)
    return unpad(aes.decrypt(edata)).decode('utf-8')


if __name__ == '__main__':
    secret = 'f8abb29f13cb932704badb0de414ab08ca9f6c63'
    value = 'hello world'
    encoded = _encrypt(secret, value)
    print('encoded:', encoded)
    decoded = _decrypt(secret, encoded)
    print('decoded:', decoded)

Help from:

• Implementing AES/ECB/PKCS5 padding in Python
• Node.js - Set padding in crypto module
• Python Encrypting with PyCrypto AES

Just for any one that is similar to me, who was finding a simple way to do the encryption and decryption for AES in python that is doing the same thing in node.js. The class here supports different bits of AES and both hex and base64 encoding that produces same result in node.js.

Also noted that if you are missing the package Crypto, you can simply install it by

pip install pycrypto

The code for python is as follows:

import base64
import hashlib
from Crypto.Cipher import AES

class AESCrypto(object):
    def __init__(self, algorithm, password):
        self.algorithm = filter(lambda x: not x.isdigit(), algorithm).lower()
        self.bits = int(filter(str.isdigit, algorithm))
        self.bs = 16
        if not self.algorithm == 'aes':
            raise Exception('Only AES crypto is supported')
        if not self.bits % 8 == 0:
            raise Exception('Bits of crypto must be a multiply of 8.')
        self.bytes = self.bits / 8
        self.password = password
        self.generateKeyAndIv()

    def generateKeyAndIv(self):
        last = ''
        allBytes = ''
        maxBytes = self.bytes + self.bs
        while len(allBytes) < maxBytes:
            last = hashlib.md5(last + self.password).digest()
            allBytes += last
        self.key = allBytes[:self.bytes]
        self.iv = allBytes[self.bytes:maxBytes]

    def encrypt(self, raw, outputEncoding):
        outputEncoding = outputEncoding.lower()
        raw = self._pad(raw)
        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
        encrypted = cipher.encrypt(raw)
        if outputEncoding == 'hex':
            return encrypted.encode('hex')
        elif outputEncoding == 'base64':
            return base64.b64encode(encrypted)
        else:
            raise Exception('Encoding is not supported.')

    def decrypt(self, data, inputEncoding):
        inputEncoding = inputEncoding.lower()
        if inputEncoding == 'hex':
            data = ''.join(map(chr, bytearray.fromhex(data)))
        elif inputEncoding == 'base64':
            data = base64.b64decode(data)
        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
        return self._unpad(cipher.decrypt(data))

    def _pad(self, data):
        padding = self.bs - len(data) % self.bs
        return data + padding * chr(padding)

    @staticmethod
    def _unpad(data):
        return data[0:-ord(data[-1])]

The following are examples to use the class:

Encryption Example:

password = 'some_random_password'
content = 'content_to_be_encrypted'
cipher = AESCrypto('aes192', password)
encrypted = cipher.encrypt(content, 'hex')

Decryption Example:

password = 'some_random_password'
content = 'encrypted_content'
cipher = AESCrypto('aes192', password)
decrypted = cipher.decrypt(content, 'hex')