I am using the below code to encrypt and decrypt in typescript:
<code>const AES = require('crypto-js/aes');
const Utf8 = require('crypto-js/enc-utf8');
export const encrypt = (text, passphrase) => {
return AES.encrypt(text, passphrase).toString();
export const decrypt = (ciphertext, passphrase) => {
const bytes = AES.decrypt(ciphertext, passphrase);
const originalText = bytes.toString(Utf8);
<code>const AES = require('crypto-js/aes');
const Utf8 = require('crypto-js/enc-utf8');
export const encrypt = (text, passphrase) => {
return AES.encrypt(text, passphrase).toString();
};
export const decrypt = (ciphertext, passphrase) => {
const bytes = AES.decrypt(ciphertext, passphrase);
const originalText = bytes.toString(Utf8);
return originalText;
};
</code>
const AES = require('crypto-js/aes');
const Utf8 = require('crypto-js/enc-utf8');
export const encrypt = (text, passphrase) => {
return AES.encrypt(text, passphrase).toString();
};
export const decrypt = (ciphertext, passphrase) => {
const bytes = AES.decrypt(ciphertext, passphrase);
const originalText = bytes.toString(Utf8);
return originalText;
};
Now, the encrypted message generated in Typescript is to be decrypted in a Python environment. I used Chat GPT to come up with a solution but it gave a different result.
In one of the StackOverflow answers it was mentioned that CryptoJS uses following method for AES encryption:
Now CryptoJs derives a 32 byte long encryption key for AES-256 and a
16 byte long initialization vector (iv) from the password, encrypts
the “Message” using this key, iv in AES mode CBC and (default) padding
Pkcs7.
I gave the above details as context to Chat GPT but that didn’t work either. My Python code uses cryptography library and the code looks like below.
<code>from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding
def derive_key_iv(password: str, salt: bytes, key_length=32, iv_length=16):
# Key derivation function
backend = default_backend()
length=key_length + iv_length,
key_iv = kdf.derive(password.encode())
return key_iv[:key_length], key_iv[key_length:key_length+iv_length]
def encrypt(message: str, password: str):
salt = urandom(16) # Generate a random salt
key, iv = derive_key_iv(password, salt)
backend = default_backend()
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
encryptor = cipher.encryptor()
padder = padding.PKCS7(algorithms.AES.block_size).padder()
padded_data = padder.update(message.encode()) + padder.finalize()
encrypted = encryptor.update(padded_data) + encryptor.finalize()
return salt + encrypted # prepend salt for use in decryption
def decrypt(token: bytes, password: str):
salt = token[:16] # Extract the salt from the beginning
encrypted_message = token[16:]
key, iv = derive_key_iv(password, salt)
backend = default_backend()
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
decryptor = cipher.decryptor()
padded_plaintext = decryptor.update(encrypted_message) + decryptor.finalize()
unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
plaintext = unpadder.update(padded_plaintext) + unpadder.finalize()
return plaintext.decode()
<code>from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding
from os import urandom
def derive_key_iv(password: str, salt: bytes, key_length=32, iv_length=16):
# Key derivation function
backend = default_backend()
kdf = Scrypt(
salt=salt,
length=key_length + iv_length,
n=2**14,
r=8,
p=1,
backend=backend
)
key_iv = kdf.derive(password.encode())
return key_iv[:key_length], key_iv[key_length:key_length+iv_length]
def encrypt(message: str, password: str):
salt = urandom(16) # Generate a random salt
key, iv = derive_key_iv(password, salt)
backend = default_backend()
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
encryptor = cipher.encryptor()
padder = padding.PKCS7(algorithms.AES.block_size).padder()
padded_data = padder.update(message.encode()) + padder.finalize()
encrypted = encryptor.update(padded_data) + encryptor.finalize()
return salt + encrypted # prepend salt for use in decryption
def decrypt(token: bytes, password: str):
salt = token[:16] # Extract the salt from the beginning
encrypted_message = token[16:]
key, iv = derive_key_iv(password, salt)
backend = default_backend()
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
decryptor = cipher.decryptor()
padded_plaintext = decryptor.update(encrypted_message) + decryptor.finalize()
unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
plaintext = unpadder.update(padded_plaintext) + unpadder.finalize()
return plaintext.decode()
</code>
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding
from os import urandom
def derive_key_iv(password: str, salt: bytes, key_length=32, iv_length=16):
# Key derivation function
backend = default_backend()
kdf = Scrypt(
salt=salt,
length=key_length + iv_length,
n=2**14,
r=8,
p=1,
backend=backend
)
key_iv = kdf.derive(password.encode())
return key_iv[:key_length], key_iv[key_length:key_length+iv_length]
def encrypt(message: str, password: str):
salt = urandom(16) # Generate a random salt
key, iv = derive_key_iv(password, salt)
backend = default_backend()
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
encryptor = cipher.encryptor()
padder = padding.PKCS7(algorithms.AES.block_size).padder()
padded_data = padder.update(message.encode()) + padder.finalize()
encrypted = encryptor.update(padded_data) + encryptor.finalize()
return salt + encrypted # prepend salt for use in decryption
def decrypt(token: bytes, password: str):
salt = token[:16] # Extract the salt from the beginning
encrypted_message = token[16:]
key, iv = derive_key_iv(password, salt)
backend = default_backend()
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
decryptor = cipher.decryptor()
padded_plaintext = decryptor.update(encrypted_message) + decryptor.finalize()
unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
plaintext = unpadder.update(padded_plaintext) + unpadder.finalize()
return plaintext.decode()
What can be done to get the correct decrypted result in python?