问Node.js中的AES加密和Java Android中的解密

EN

"use strict";

var aesjs = require("aes-js");
var sha256 = require("js-sha256");

const getKeyArray = function() { // decryption on Android doesn't support 256 bit keys with AES/CTR, so I'm using only 128 bits
  let buffer = sha256.arrayBuffer("mystrongkey");
  let keyArray =  new Uint8Array(buffer);
  const keySize = 16;
  let arr = new Array;
  for (var i = 0; i < keySize; i++) {
    arr.push(keyArray[i]);
  }
  return arr;
}

module.exports = {
  getKey: function() {
    return getKeyArray();
  },
  getIV: function() {
    return new aesjs.Counter(5);
  },
  encrypt: function(text) {
    var textBytes = aesjs.utils.utf8.toBytes(text);

    // The counter is optional, and if omitted will begin at 1
    var aesCtr = new aesjs.ModeOfOperation.ctr(getKeyArray(), this.getIV());
    var encryptedBytes = aesCtr.encrypt(textBytes);

    // To print or store the binary data, you may convert it to hex
    var encryptedHex = aesjs.utils.hex.fromBytes(encryptedBytes);
    return encryptedHex;
  },
  decrypt: function(encryptedHex) {
    // When ready to decrypt the hex string, convert it back to bytes
    var encryptedBytes = aesjs.utils.hex.toBytes(encryptedHex);

    // The counter mode of operation maintains internal state, so to
    // decrypt a new instance must be instantiated.
    var aesCtr = new aesjs.ModeOfOperation.ctr(getKeyArray(), this.getIV());
    var decryptedBytes = aesCtr.decrypt(encryptedBytes);

    // Convert our bytes back into text
    var decryptedText = aesjs.utils.utf8.fromBytes(decryptedBytes);
    return decryptedText;
  }
};

package com.mypackage;

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

class Cypher {
    private final static char[] hexArray = "0123456789ABCDEF".toCharArray();

    private static String KEY = "mystrongkey";

    /**
     * Decrypt a given hex string,
     * 08768efebc = Hello
     * @param hexString
     * @return
     */
    static String decrypt(String hexString) throws Exception{
        Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");

        IvParameterSpec ivSpec = new IvParameterSpec(new byte[] { // got this one by console.log(Cypher.getIv()) from Cypher.js
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                5
        });

        cipher.init(Cipher.DECRYPT_MODE, getEncryptionKey(KEY), ivSpec);

        byte[] decrypted = cipher.doFinal(hexStringToByteArray(hexString));

        return new String(decrypted);
    }

    static String encrypt(String string) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");

        IvParameterSpec ivSpec = new IvParameterSpec(new byte[] {
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                5
        });

        cipher.init(Cipher.ENCRYPT_MODE, getEncryptionKey(KEY), ivSpec);

        byte[] encrypted = cipher.doFinal(string.getBytes());

        return bytesToHex(encrypted);
    }

    private static SecretKeySpec getEncryptionKey(String key) throws Exception {

        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        digest.update(key.getBytes("UTF-8"));
        byte[] keyBytes = new byte[16];
        System.arraycopy(digest.digest(), 0, keyBytes, 0, keyBytes.length);
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        return secretKeySpec;

    }

    static String bytesToHex(byte[] bytes) {
        char[] hexChars = new char[bytes.length * 2];
        for ( int j = 0; j < bytes.length; j++ ) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }
        return new String(hexChars);
    }

    static byte[] hexStringToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                    + Character.digit(s.charAt(i+1), 16));
        }
        return data;
    }
}