Nodejs加密的字符串与Java不匹配：AES-256-CBC

Question

Hi I have written nodejs encryption and java encryption by using same algorithm on both the side. But Java and NodeJS are returning different encrypted string. Please help me here.

//Here is my Java Code

import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.spec.AlgorithmParameterSpec;

    import javax.crypto.Cipher;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    import java.util.Base64;

    public enum AESUtil {
        ;
        private static final String ENCRYPTION_KEY = "RwcmlVpg";
        private static final String ENCRYPTION_IV = "4e5Wa71fYoT7MFEX";

        public static String encrypt(String src) {
            try {
                Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
                cipher.init(Cipher.ENCRYPT_MODE, makeKey(), makeIv());
                Base64.Encoder encoder = Base64.getEncoder();
                return encoder.encodeToString(cipher.doFinal(src.getBytes()));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        public static String decrypt(String src) {
            String decrypted = "";
            try {
                Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
                cipher.init(Cipher.DECRYPT_MODE, makeKey(), makeIv());
                Base64.Decoder decoder = Base64.getDecoder();
                decrypted = new String(cipher.doFinal(decoder.decode(src)));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            return decrypted;
        }

        static AlgorithmParameterSpec makeIv() {
            try {
                return new IvParameterSpec(ENCRYPTION_IV.getBytes("UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return null;
        }

        static Key makeKey() {
            try {
                MessageDigest md = MessageDigest.getInstance("SHA-256");
                byte[] key = md.digest(ENCRYPTION_KEY.getBytes("UTF-8"));
                return new SecretKeySpec(key, "AES");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }

            return null;
        }
    }

//Below is the code to test above code

    public class AESMain {

        /**
         * @param args
         */
        public static void main(String[] args) {
            String src = "Hello,CryptWorld";
            String encrypted = AESUtil.encrypt(src);
            String decrypted = AESUtil.decrypt(encrypted);
            System.out.println("src: " + src);
            System.out.println("encrypted: " + encrypted);
            System.out.println("decrypted: " + decrypted);
        }

    }

Response from the above code is

src: Hello,CryptWorld
encrypted: rh7ro9NH1XZeLX95paLETDgYxRbnDoOIrxarO0Sy73s=
decrypted: Hello,CryptWorld

//Node JS Code

var Encrypt, crypto;

crypto = require("crypto");


Encrypt = module.exports = (function() {
  var b64dec, b64enc, cipher, decrypt, encrypt, iv, key;
  key = crypto.createHash("sha256").update("RwcmlVpg").digest();
  iv = '4e5Wa71fYoT7MFEX';
  cipher = function(mode, data) {
    var encipher, encoded;
    encipher = crypto[mode]("aes-256-cbc", key, iv);
    encoded = encipher.update(data);
    encoded += encipher.final();
    return encoded;
  };
  encrypt = function(data) {
    return b64enc(cipher("createCipheriv", data));
  };
  decrypt = function(data) {
    return cipher("createDecipheriv", b64dec(data));
  };
  b64enc = function(data) {
    var b;
    b = new Buffer(data, "binary");
    return b.toString("base64");
  };
  b64dec = function(data) {
    var b;
    b = new Buffer(data, "base64");
    return b.toString("binary");
  };
  return {
    encrypt: encrypt,
    decrypt: decrypt
  };
})();
var expected = Encrypt.encrypt("Hello,CryptWorld");
console.log("expected " + expected);

The Response from Node JS is

expected /R79/f1H/XZeLX95/f39TDgY/Rb9Dv39/Rb9O0T9/Xs=

The node js version is v6.10.1 and JDK version 1.8.0_77.

I really don't know what I am missing.

Answer 1

My first hint would be to make sure that you exactly the same:

1. character encoding
2. line endings

in both of your programs, for the text being encrypted and for the keys. Try printing the text buffers and keys as hex and compare those before you even do any encryption. If they differ then there's your problem. If they're the same then it may be a problem with the encryption itself.

Note that Node uses UTF-8 by default while Java uses UCS-2 internally as far as I know. I see you're making some attempts to convert the encoding but double check the results in both envirements for bot the keys and the clear text just before the encryption step.

Also make sure that you're not encrypting base64 representation of the string instead of the string itself, or that if you use base64 for the key then you do it consistently.

Also, print both keys before the encryption. You're building them programmatically so make sure you know what they are at the end.

If you make sure that you have the same keys, the same messages, the same encoding, line endings and representation (hex, base64 etc.) then use some online tool for AES encryption like:

• http://aesencryption.net/
• http://aes.online-domain-tools.com/
• https://www.browserling.com/tools/aes-encrypt

and compare which of your program does the job correctly.

Answer 2

I'm not a javascript or node.js expert, but I think the problem is that the cipher.update() and cipher.final() are returning instances of Buffer , not string. Therefore you must use Buffer.concat(...) to concatenate them, ie

cipher = function (mode, data) {
    var encipher, encoded;
    encipher = crypto[mode]("aes-256-cbc", key, iv);
    cipher1 = encipher.update(data);
    cipher2 = encipher.final();
    return  Buffer.concat([cipher1, cipher2]);
};

Additionally, you should never use this String.getBytes() method nor this String(byte[]) constructor in any code that strives to achieve portability or interoperability. Instead, always specify the charset explicitly. I would recommend UTF_8 exclusively, eg so use String.getBytes(StandardCharsets.UTF_8) and new String(byte[], StandardCharsets.UTF_8) .