How to get java equivalent of encryptJs in javascript

As you are using different key and iv values in Java and Javascript it is ovious that you will different results in Java and Javascript, as you already were told from @Artjom B.

As well your "message to encrypt" ("toenc" or "body") differs as well and won't get the same result.

I setup a simplified Java program and adjusted some missing charset encodings. For simplicity I used just a simple string to test the en- and decryption on both sides - I leave it up to you to find an identical solution for your "message to encrypt" on Java and Javascript.

The Javascript program is using CryptoJS for encryption and gets the same input values for key, iv and plaintext.

Both programs give the same encrypted value in hex:

525106e181b2ad0b507439f54d690dfaa6e22ae2c96cde79c532a2b868d5e824637b91cc59854592343c26c39f83f452

Please note: both programs do not have any exception handling and are for educational purpose only.

For a live test I setup two "fiddles" where you can test the programs with your own values:

Java: https://paiza.io/projects/e/tMzKTcUrBFCgvrTKf4hVow Javascript: https://playcode.io/672028/

Java code:

import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;

public class Main {
    private String iv = "9%Ysr^xyBTrPr!$Y";
    private String secretkey = "GnxUFjKw9(bk7Ay$";
    private IvParameterSpec ivspec;
    private SecretKeySpec keyspec;
    private Cipher cipher;

    public static void main(String args[]) throws UnsupportedEncodingException, Exception {
        Main crypta = new Main();
        //String toenc = "1";
        /*
        String toenc = " “srcAccount”:\"0011295527\",\r\n" +
                "“requestId\":\"12345678901234567890\",\r\n" +
                "“pin”:\"3019\"";
        */
        String toenc = "The quick brown fox jumps over the lazy dog";
        String enc = "";
        String dec = "";
        // encrypt the value
        //enc = crypta.encrypt(toenc);
        enc = crypta.encrypt(toenc);
        // encrypted value print out
        System.out.println(" ENCED : " + enc);
        // decrypt the value
        dec = crypta.decrypt(enc);
        // decrypted value print out
        System.out.println(" DECED : " + dec);
    }

    public Main(String keyz, String ivStr) {
        ivspec = new IvParameterSpec(ivStr.getBytes(StandardCharsets.UTF_8));
        keyspec = new SecretKeySpec(keyz.getBytes(StandardCharsets.UTF_8), "AES");
        try {
            cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        }
    }

    public Main()
    {
        ivspec = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));
        keyspec = new SecretKeySpec(secretkey.getBytes(StandardCharsets.UTF_8), "AES");
        System.out.println("this ivspec = " + ivspec);
        try
        {
            cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        }
        catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        }
        catch (NoSuchPaddingException e)
        {
            e.printStackTrace();
        }}

    public String encrypt(String text) throws SecurityException {
        System.out.println("text = " + text);
        if (text == null || text.length() == 0) {
            throw new SecurityException("Empty string");
        }
        byte[] encrypted = null;
        try {
            cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
            encrypted = cipher.doFinal(text.getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            throw new SecurityException("[encrypt] " + e.getMessage());
        }
        return bytesToHex(encrypted);
    }

    public String decrypt(String code) throws SecurityException, UnsupportedEncodingException {
        if (code == null || code.length() == 0) {
            throw new SecurityException("Empty string");
        }
        byte[] decrypted = null;
        try {
            cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);
            decrypted = cipher.doFinal(hexToBytes(code));
        } catch (Exception e) {
            e.printStackTrace();
            throw new SecurityException("[decrypt] " + e.getMessage());
        }
        return new String(decrypted, StandardCharsets.UTF_8);
    }

    public static String bytesToHex(byte[] data)
    {
        if (data==null) {
            return null;
        }
        int len = data.length;
        String str = "";
        for (int i=0; i<len; i++)
        {
            if ((data[i]&0xFF)<16) {
                str = str + "0" + Integer.toHexString(data[i]&0xFF);
            }
            else {
                str = str + Integer.toHexString(data[i]&0xFF);
            }}return str;
    }

    public static byte[] hexToBytes(String str) {
        if (str == null) {
            return null;
        } else if (str.length() < 2) {
            return null;
        } else {
            int len = str.length() / 2;
            byte[] buffer = new byte[len];
            for (int i = 0; i < len; i++) {
                buffer[i] = (byte) Integer.parseInt(str.substring(i * 2, i * 2 + 2), 16);
            }
            return buffer;
        }
    }
}

Javascript code:

let iv = '9%Ysr^xyBTrPr!$Y';
let secret_key = 'GnxUFjKw9(bk7Ay$';
let plaintext = 'The quick brown fox jumps over the lazy dog';
console.log('plaintext: ', plaintext);

plaintext = CryptoJS.enc.Utf8.parse(plaintext);
secret_key = CryptoJS.enc.Utf8.parse(secret_key);
iv = CryptoJS.enc.Utf8.parse(iv);

var ciphertext = CryptoJS.AES.encrypt(plaintext, secret_key, {
  iv: iv,
  padding: CryptoJS.pad.Pkcs7,
  mode: CryptoJS.mode.CBC,
});

console.log('ciphertext: ', ciphertext.ciphertext.toString());

var decrypted = CryptoJS.AES.decrypt(ciphertext, secret_key,{
  iv: iv,
  padding: CryptoJS.pad.Pkcs7,
  mode: CryptoJS.mode.CBC,
});

console.log('decrypted (hex): ', decrypted.toString());
console.log('decrypted (str): ', CryptoJS.enc.Utf8.stringify(decrypted).toString());