Why does Rijndael encryption using rjndael-js in Node.js yield different outputs compared to Java and C#?

I'm getting different encryption outputs in Node.js with rjndael-js compared to my Java and C# implementations. I suspect the discrepancy arises from differences in how the plaintext string is encoded and possibly from padding differences between the libraries. The Java and C# code produce the same result, but the Node.js version does not match.

Below is the Node.js implementation:

JAVASCRIPTCopied
const toHexString = (bytes) => {
  return Array.from(bytes, (byte) => {
    return ('0' + (byte & 0xff).toString(16)).slice(-2);
  }).join('');
};

const hexToBytes = (hex) => {
  var bytes = [];
  for (var c = 0; c < hex.length; c += 2) {
    bytes.push(parseInt(hex.substr(c, 2), 16));
  }
  return bytes;
};

const stringToEncrypt = 'test';
const keyAsHex = '12341234123412341234123412341234';
const ivAsHex = '43214321432143214321432143214321';

const keyAsBytes = hexToBytes(keyAsHex);
const ivAsBytes = hexToBytes(ivAsHex);
const Rijndael = require('rijndael-js');
const cipher = new Rijndael(keyAsBytes, 'cbc');
const cipherAsBytes = cipher.encrypt(stringToEncrypt, 128, ivAsBytes);

console.log("cipherAsHex",toHexString(cipherAsBytes)); //outputs: 172e3a9bec36e96f8f7f1da65e6e876c

Here is the Java implementation:

JAVACopied
import java.util.*;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

public class cryptoTesting {
    public static void main(String[] args) {
        try{

            String keyAsHex = "12341234123412341234123412341234";
            String ivAsHex = "43214321432143214321432143214321";
            String message = "test";

            byte[] messageAsBytes = message.getBytes();
            byte[] keyAsBytes = HexFormat.of().parseHex(keyAsHex);
            byte[] ivAsBytes = HexFormat.of().parseHex(ivAsHex);

            System.out.println(Arrays.toString(messageAsBytes));
            System.out.println(Arrays.toString(keyAsBytes));
            System.out.println(Arrays.toString(ivAsBytes));
            
            String plaintext = "test";
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            
            //You can use ENCRYPT_MODE or DECRYPT_MODE
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyAsBytes, "AES"), new IvParameterSpec(ivAsBytes));
            byte[] cipherAsBytes = cipher.doFinal(messageAsBytes);
            String cipherAsHex = HexFormat.of().formatHex(cipherAsBytes);
            System.out.println (cipherAsHex); //outputs: 647768a8c969dc195e34c7968514494f
        
        } catch (Exception exc){
            exc.printStackTrace(System.out);
            //System.out.write(exc);
        }
    }
}

And the C# version:

CSHARPCopied
using System;
using System.IO;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Text;

namespace RijndaelManaged_Example
{
    class RijndaelExample
    {
        public static void Main()
        {
            string original = "test";

            // Create a new instance of the RijndaelManaged
            // class.  This generates a new key and initialization
            // vector (IV).
            using (RijndaelManaged myRijndael = new RijndaelManaged())
            {

                myRijndael.Key = Convert.FromHexString("12341234123412341234123412341234");
                myRijndael.IV = Convert.FromHexString("43214321432143214321432143214321");
                myRijndael.BlockSize = 128;

                // Encrypt the string to an array of bytes.
                byte[] encrypted = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV);
                PrintByteArray(encrypted);
                Console.WriteLine(Convert.ToHexString(encrypted)); //647768A8C969DC195E34C7968514494F

            }
        }

        public static void PrintByteArray(byte[] bytes)
        {
            var sb = new StringBuilder("new byte[] { ");
            foreach (var b in bytes)
            {
                sb.Append(b + ", ");
            }
            sb.Append("}");
            Console.WriteLine(sb.ToString());
        }

        static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
        {
      
            byte[] encrypted;
            // Create an RijndaelManaged object
            // with the specified key and IV.
            using (RijndaelManaged rijAlg = new RijndaelManaged())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;
                rijAlg.BlockSize = 128;

                
                Console.WriteLine(rijAlg.IV);

                // Create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {

                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                    }

                    encrypted = msEncrypt.ToArray();
                }
            }

            PrintByteArray(Key);
            PrintByteArray(IV);

            // Return the encrypted bytes from the memory stream.
            return encrypted;
        }
    }
}

I would appreciate any insights or suggestions on how to adjust the Node.js implementation (or use an alternative library) to match the outputs from Java and C#. The provided answers highlight potential causes such as encoding differences (e.g., converting the plaintext to a Buffer) and padding discrepancies (zero-padding vs PKCS#7).