How to decrypt code in Crypto Swift which is encrypted by default config of CryptoJS

[nirmal-opencrowd]

I'm trying to decrypt a string which is encrypted by CryptoJS AES encryption in Swift but I don't know if I'm using the right configuration to decrypt it.

This function used for encrypting the message

var encrypted = CryptoJS.AES.encrypt("Message", "Secret Passphrase");

Here is code, which I'm using in swift

import Foundation
import CryptoSwift

static func decryptAES256CryptoJS(encryptedBase64: String, passphrase: String) {
        // Step 1: Decode Base64
        guard let encryptedData = Data(base64Encoded: encryptedBase64) else {
            print("❌ Base64 decoding failed")
            return
        }

        // Step 2: Extract Salt (First 8 bytes) and Ciphertext
        let salt = encryptedData.subdata(in: 8..<16)  // Extract Salt (Next 8 bytes after "Salted__")
        let ciphertext = encryptedData.subdata(in: 16..<encryptedData.count) // Remaining bytes

        // Step 3: Derive Key & IV using PBKDF2 (1000 iterations, SHA1, 48-byte output)
        do {
            let keyAndIV = try PKCS5.PBKDF2(
                password: passphrase.bytes,
                salt: salt.bytes,
                iterations: 1000,
                keyLength: 48,  // 32 bytes for Key + 16 bytes for IV = 48 bytes
                variant: .sha1
            ).calculate()

            let key = Array(keyAndIV[0..<32])  // First 32 bytes → AES-256 Key
            let iv = Array(keyAndIV[32..<48])  // Next 16 bytes → IV

            // Step 4: AES-256 CBC Decryption with PKCS7 Padding
            let aes = try AES(key: key, blockMode: CBC(iv: iv), padding: .pkcs7)
            let decryptedBytes = try aes.decrypt(ciphertext.bytes)

            
            // Step 6: Convert the decrypted bytes to a string (assuming it's UTF-8 encoded)
            if let decryptedString = String(bytes: decryptedBytes, encoding: .utf8) {
                print("Decrypted Message: \(decryptedString)")
            } else {
                print("Error: Decrypted data is not valid UTF-8")
            }

        } catch {
            print("❌ Decryption error: \(error)")
        }
    }

[user163]

CryptoJS does not use PBKDF2 as the key derivation function by default, but the OpenSSL proprietary key derivation function EVP_BytesToKey() in order to be compatible with OpenSSL. An implementation of this function is therefore required. Here is a lightweight implementation.

For some reason, however, this implementation does not take the salt into account and must be extended accordingly, e.g.:

func evpBytesToKey(password:String, salt:[UInt8], keyLen:Int, ivLen:Int) -> ([UInt8], [UInt8]) {

    var m = [Data]()
    guard let passwd = password.data(using: String.Encoding.utf8) else {
        return ([], []);
    }
    while m.reduce(0, {$0 + $1.count}) < keyLen + ivLen {
        let data = m.count > 0 ? m.last! + passwd + salt : passwd + salt 
        m.append(data.md5())
    }
    let final = m.reduce(Data(), +)
    return (Array(final.bytes[0...(keyLen - 1)]), Array(final.bytes[keyLen...(keyLen + ivLen - 1)]))
}

and the call of this function must be adapted accordingly:

// Step 3: Derive Key & IV using EVP_BytesToKey (1 iteration, MD5, 48-byte output)
do {
     let (key, iv) = try evpBytesToKey(
         password: passphrase, salt: Array(salt), keyLen: 32, ivLen: 16
     )
     ...

---

Test:

CryptoJS side:

var encrypted = CryptoJS.AES.encrypt("The quick brown fox jumps over the lazy dog", "Secret Passphrase");
console.log(encrypted.toString())

Sample output:

U2FsdGVkX1+v7MWpYVEdwijrtaWww4qmhEi2Vx6cwcBVlGm3klyEMdxvrzy9M49TqxALI768/mYVbeP1AqAEzw==

Swift side:

decryptAES256CryptoJS(encryptedBase64: "U2FsdGVkX1+v7MWpYVEdwijrtaWww4qmhEi2Vx6cwcBVlGm3klyEMdxvrzy9M49TqxALI768/mYVbeP1AqAEzw==", passphrase: "Secret Passphrase")

Output:

Decrypted Message: The quick brown fox jumps over the lazy dog

---

It should be noted that EVP_BytesToKey() is considered insecure nowadays, PBKDF2 is the more secure alternative. CryptoJS also supports PBKDF2, but not for the implicit key derivation (which can be changed with the appropriate effort).
Alternatively, the explicit approach can be chosen, in which the key and IV are explicitly derived from the password and salt in a first step and then encrypted or decrypted in a second step.