在Java和JavaScript之间实现AES

我正在尝试实现一个aes/cbc/PKCS5P添加算法。我从JS中的一些CryptoJS开始，并在几秒钟内发现了加密和解密的工作原理。我搜索了许多兼容的解决方案，因为返回的值总是错误的

不重要：我的目标是以下概念：

用户帐户在服务器端创建，密码用SHA-256散列

用户尝试登录网页（客户端JS），其中一个数据包以其普通用户名开始发送到服务器，随后是一个AES加密的JSONObject，并显示一条简单的成功消息。AES的密钥是本地散列的用户密码的SHA-256

服务器接收此数据包并检查所有用户帐户，如果其中任何名称与数据包的开头匹配。在这种情况下，应用程序分离其中的AES部分，并尝试使用自创建用户以来服务器知道的SHA-256哈希密码对其进行解密

如果解密成功，客户端和服务器将继续使用此密钥，并在任何时候都不会使用websocket传输普通AES密钥的情况下进行良好的通信。如果解密失败，用户将收到错误消息“凭据不正确”

这只是为了让你的信息帮助我；）因为我不知道CryptoJS对它获取的数据到底做了什么，所以我从Java开始，最后使用以下Java实现：

import io.cloudsystem.module.network.NetworkModule;
import io.netty.handler.codec.DecoderException;

import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Base64;

public class Crypto {

public static String getSHA256(String password) {

    try {

        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        digest.update(password.getBytes("UTF-8"));

        byte[] dig = digest.digest();
        String base = Base64.getEncoder().encodeToString(dig);
        System.out.println("SHA-KEY (size): " + dig.length);
        System.out.println("SHA-KEY (raw): " + new String(dig, "UTF-8"));
        System.out.println("SHA-KEY (base): " + base);

        return base;

    } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
        NetworkModule.handleException(e);
    }

    return null;

}

public static String encrypt(String plainText, String key) {

    try {

        byte[] clean = plainText.getBytes("UTF-8");

        int ivSize = 16;
        byte[] iv = new byte[ivSize];
        SecureRandom random = new SecureRandom();
        random.nextBytes(iv);
        IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);

        System.out.println("ENC-IV (length): " + ivParameterSpec.getIV().length);
        System.out.println("ENC-IV (raw): " + new String(ivParameterSpec.getIV(), "UTF-8"));

        byte[] keyFetch = key.getBytes("UTF-8");
        byte[] keyBytes = new byte[16];
        System.arraycopy(keyFetch, 0, keyBytes, 0, keyBytes.length);
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");

        System.out.println("ENC-KEY (length): " + secretKeySpec.getEncoded().length);
        System.out.println("ENC-KEY (raw): " + new String(secretKeySpec.getEncoded(), "UTF-8"));

        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
        byte[] encrypted = cipher.doFinal(clean);

        System.out.println("ENC-RAW (length): " + encrypted.length);
        System.out.println("ENC-RAW (raw): " + new String(encrypted, "UTF-8"));

        byte[] encryptedIVAndText = new byte[ivSize + encrypted.length];
        System.arraycopy(iv, 0, encryptedIVAndText, 0, ivSize);
        System.arraycopy(encrypted, 0, encryptedIVAndText, ivSize, encrypted.length);

        System.out.println("ENC-FET (length): " + encryptedIVAndText.length);
        System.out.println("ENC-FET (raw): " + new String(encryptedIVAndText, "UTF-8"));

        String base = Base64.getEncoder().encodeToString(encryptedIVAndText);
        System.out.println("ENC-BASE: " + base);
        return base;

    } catch (NoSuchAlgorithmException | NoSuchPaddingException | UnsupportedEncodingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException | InvalidAlgorithmParameterException e) {
        NetworkModule.handleException(e);
    }

    return null;

}

public static String decrypt(String encryped, String key) {

    byte[] encryptedIvTextBytes = Base64.getDecoder().decode(encryped);
    int ivSize = 16;
    int keySize = 16;
    try {
    byte[] iv = new byte[ivSize];
    System.arraycopy(encryptedIvTextBytes, 0, iv, 0, iv.length);
    IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);

    System.out.println("DEC-IV (length): " + ivParameterSpec.getIV().length);
    System.out.println("DEC-IV (raw): " + new String(ivParameterSpec.getIV(), "UTF-8"));

    int encryptedSize = encryptedIvTextBytes.length - ivSize;
    byte[] encryptedBytes = new byte[encryptedSize];
    System.arraycopy(encryptedIvTextBytes, ivSize, encryptedBytes, 0, encryptedSize);

        System.out.println("DEC-ENC (length): " + encryptedBytes.length);
        System.out.println("DEC-ENC (raw): " + new String(encryptedBytes, "UTF-8"));

    byte[] keyFetch = key.getBytes();
    byte[] keyBytes = new byte[keySize];
    System.arraycopy(keyFetch, 0, keyBytes, 0, keyBytes.length);
    SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");

        System.out.println("DEC-KEY (length): " + secretKeySpec.getEncoded().length);
        System.out.println("DEC-KEY (raw): " + new String(secretKeySpec.getEncoded(), "UTF-8"));

        Cipher cipherDecrypt = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipherDecrypt.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
        byte[] decrypted = cipherDecrypt.doFinal(encryptedBytes);

        System.out.println("DEC (length): " + decrypted.length);
        System.out.println("DEC: " + new String(decrypted));

        return new String(decrypted);

    } catch (UnsupportedEncodingException | NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException | InvalidAlgorithmParameterException | InvalidKeyException e) {
        NetworkModule.handleException(e);
    }

        return null;

    }

}

很抱歉代码中的填充错误。一个示例场景可能会以如下方式结束：

SHA-KEY (size): 32
SHA-KEY (raw): �F os���>P�`��o�8e5*gf�
 �
SHA-KEY (base): 4kYAb3O+EQTB9hE+UJxg9rNv8AQ4ZTUeKmdmzxoKAJE=
ENC-IV (length): 16
ENC-IV (raw): �I?dm�@�ܹTa؞�
ENC-KEY (length): 16
ENC-KEY (raw): 4kYAb3O+EQTB9hE+
ENC-RAW (length): 16
ENC-RAW (raw): B;��\`A0��z��
ENC-FET (length): 32
ENC-FET (raw): �I?dm�@�ܹTa؞�B;��\`A0��z��
ENC-BASE: FfVJP2RtuED53LlUYdie9EI7uJITXGBBMN7OepQeAqU=
DEC-IV (length): 16
DEC-IV (raw): �I?dm�@�ܹTa؞�
DEC-ENC (length): 16
DEC-ENC (raw): B;��\`A0��z��
DEC-KEY (length): 16
DEC-KEY (raw): 4kYAb3O+EQTB9hE+
DEC (length): 10
DEC: helloworld

我的结果是：加密和解密在java中工作。现在我需要将其实现为javascript。经过长时间的测试、编码、解码，以及UTF16（JS默认值）和UTF8（Java字符集）的差异，我最终得到了与Java中相同的值，代码如下：

var key = new Buffer("4kYAb3O+EQTB9hE+UJxg9rNv8AQ4ZTUeKmdmzxoKAJE=").subarray(0, 16)
var cryptobase = "FfVJP2RtuED53LlUYdie9EI7uJITXGBBMN7OepQeAqU="
varr crypto = new Buffer(cryptobase, 'base64')
var iv = crypto.subarray(0, 16)
var text = crypto.subarray(16, crypto.length)

console.log("Key: " + new TextDecoder("utf-8").decode(key))
console.log("IV: " + new TextDecoder("utf-8").decode(iv))
console.log("Text: " + new TextDecoder("utf-8").decode(text))

console.log(CryptoJS.AES.decrypt(text, key, {iv: iv}).toString(CryptoJS.enc.Utf8))

结果如下：

Key: 4kYAb3O+EQTB9hE+
IV: �I?dm�@�ܹTa؞�
Text: B;��\`A0��z��

我们在Java端解密时得到的值完全相同。除了一个：CryptoJS结果。这是“”（清空字符串） 现在我的大问题是：如何继续，我可以使用CryptoJS吗？我做错了什么，不安全还是没有故障保护

请识别：

• 我看到了，但对我不起作用，我想用我自己的钥匙。再次测试。使用pbkdf2仍有不同的值

• 我不想使用AES-256，因为我不想要求软件用户安装JCE

• 我知道SHA-256不是散列密码的方法。我正在生产中使用pbkdf2

---

我在源代码中实现了aes示例，而不是在描述中实现了aes示例后，它就开始工作了。 我修改了它以在一个字符串内传递数据，因此加密/解密只需要密码和密钥。 以下是我的源代码（mpetersens aes示例的修改版本）：

JavaScript:

const CryptoJS = require("crypto-js")
var Crypto = new AES()

function AES() {}

AES.prototype.generateKey = function(salt, passPhrase) {
    var key = CryptoJS.PBKDF2(passPhrase, CryptoJS.enc.Hex.parse(salt), { keySize: 4, iterations: 1000 });
    return key;
}

AES.prototype.encrypt = function(password, message) {
    var salt = CryptoJS.lib.WordArray.random(128/8).toString(CryptoJS.enc.Hex)
    var iv = CryptoJS.lib.WordArray.random(128/8).toString(CryptoJS.enc.Hex)
    var encrypted = CryptoJS.AES.encrypt(message, this.generateKey(salt, password), { iv: CryptoJS.enc.Hex.parse(iv) })
    var base64 = encrypted.ciphertext.toString(CryptoJS.enc.Base64)
    return salt + base64.substring(0, base64.length-2) + iv
}

AES.prototype.decrypt = function(password, message) {
    var salt = message.substring(0, 32)
    var iv = message.substring(message.length-32, message.length)
    var cipherParams = CryptoJS.lib.CipherParams.create({
        ciphertext: CryptoJS.enc.Base64.parse(message.substring(32, message.length-32) + "==")
    });
    var decrypted = CryptoJS.AES.decrypt(cipherParams, this.generateKey(salt, password), { iv: CryptoJS.enc.Hex.parse(iv) })
    return decrypted.toString(CryptoJS.enc.Utf8)
}

爪哇：

private static final char[]HEX=新字符[]{'0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'A'，'b'，'c'，'D'，'e'，'F'}；
私有静态密码；
公共静态void init（）{
试一试{
cipher=cipher.getInstance（“AES/CBC/PKCS5Padding”）；
}捕获（NoSuchPaddingException | NoSuchAlgorithme异常）{
NetworkModule.handleException（e）；
}
}
公共静态字符串加密（字符串密码、字符串消息）{
试一试{
串盐=随机（16）；
字符串iv=随机（16）；
SecretKey=generateKey（salt，密码）；
byte[]encrypted=doFinal（Cipher.ENCRYPT_模式，密钥，iv，message.getBytes（“UTF-8”）；
字符串代码=Base64.getEncoder（）.encodeToString（加密）；
返回salt+code.substring（0，code.length（）-2）+iv；
}捕获（不支持的编码异常e）{
NetworkModule.handleException（e）；
返回null；
}
}
公共静态字符串解密（字符串密码、字符串消息）{
试一试{
字符串salt=message.substring（0,32）；
字符串iv=message.substring（message.length（）-32，message.length（））；
字符串base=message=message.substring（32，message.length（）-32）+“=”；
SecretKey=generateKey（salt，密码）；
byte[]decrypted=doFinal（Cipher.DECRYPT_模式，key，iv，Base64.getDecoder（）.decode（base））；
返回新字符串（已解密，“UTF-8”）；
}捕获（不支持的编码异常e）{
NetworkModule.handleException（e）；
返回null；
}
}
私有静态字节[]doFinal（int-encryptMode，SecretKey密钥，字符串iv，字节[]字节）{
试一试{
init（encryptMode，key，新的IvParameterSpec（十六进制（iv））；
返回cipher.doFinal（字节）；
}捕获（InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e）{
NetworkModule.handleException（e）；
返回null；
}
}
私有静态SecretKey generateKey（字符串salt、字符串密码短语）{
试一试{
SecretKeyFactory factory=SecretKeyFactory.getInstance（“PBKDF2WithHmacSHA1”）；
KeySpec spec=new-PBEKeySpec（passphrase.toCharArray（），十六进制（salt），1000128）；
SecretKey key=newsecretkeyspec（factory.generateSecret（spec.getEncoded（），“AES”）；
返回键；
}捕获（NoSuchAlgorithmException | InvalidKeySpece异常）{
NetworkModule.handleException（e）；
返回null；
}
}
私有静态随机字符串（整数长度）{
字节[]salt=新字节[长度]；
新SecureRandom（）.nextBytes（salt）；
返回十六进制（盐）；
}
专用静态字符串十六进制（字节[]数据）{
int l=数据长度；
char[]out=新字符[l>>4]；
out[var5++]=HEX[15&数据[i]]；
}
返回新字符串（out）；
}
专用静态字节[]十六进制（字符串十六进制）{
char[]data=hex.toCharArray（）；
int len=data.length；
如果（（len&1）！=0）{
返回null；
}否则{
byte[]out=新字节[len>>1]；
int i=0；
对于（int j=0；jprivate static final char[] HEX = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'b', 'c', 'D', 'e', 'F'};
private static Cipher cipher;

public static void init() {

    try {
        cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    } catch (NoSuchPaddingException | NoSuchAlgorithmException e) {
        NetworkModule.handleException(e);
    }

}

public static String encrypt(String password, String message) {

    try {

        String salt = random(16);
        String iv = random(16);
        SecretKey key = generateKey(salt, password);
        byte[] encrypted = doFinal(Cipher.ENCRYPT_MODE, key, iv, message.getBytes("UTF-8"));
        String code = Base64.getEncoder().encodeToString(encrypted);
        return salt + code.substring(0, code.length() - 2) + iv;

    } catch (UnsupportedEncodingException e) {
        NetworkModule.handleException(e);
        return null;
    }

}

public static String decrypt(String password, String message) {

    try {

        String salt = message.substring(0, 32);
        String iv = message.substring(message.length() - 32, message.length());
        String base = message = message.substring(32, message.length() - 32) + "==";
        SecretKey key = generateKey(salt, password);
        byte[] decrypted = doFinal(Cipher.DECRYPT_MODE, key, iv, Base64.getDecoder().decode(base));
        return new String(decrypted, "UTF-8");

    } catch (UnsupportedEncodingException e) {
        NetworkModule.handleException(e);
        return null;
    }

}

private static byte[] doFinal(int encryptMode, SecretKey key, String iv, byte[] bytes) {

    try {

        cipher.init(encryptMode, key, new IvParameterSpec(hex(iv)));
        return cipher.doFinal(bytes);

    } catch (InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
        NetworkModule.handleException(e);
        return null;
    }

}

private static SecretKey generateKey(String salt, String passphrase) {

    try {

        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
        KeySpec spec = new PBEKeySpec(passphrase.toCharArray(), hex(salt), 1000, 128);
        SecretKey key = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");
        return key;

    } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
        NetworkModule.handleException(e);
        return null;
    }

}

private static String random(int length) {
    byte[] salt = new byte[length];
    new SecureRandom().nextBytes(salt);
    return hex(salt);
}

private static String hex(byte[] data) {

    int l = data.length;
    char[] out = new char[l << 1];
    int i = 0;

    for (int var5 = 0; i < l; ++i) {
        out[var5++] = HEX[(240 & data[i]) >>> 4];
        out[var5++] = HEX[15 & data[i]];
    }

    return new String(out);

}

private static byte[] hex(String hex) {

    char[] data = hex.toCharArray();
    int len = data.length;

    if ((len & 1) != 0) {
        return null;
    } else {

        byte[] out = new byte[len >> 1];
        int i = 0;

        for (int j = 0; j < len; ++i) {

            int f = Character.digit(data[j], 16) << 4;
            ++j;
            f |= Character.digit(data[j], 16);
            ++j;
            out[i] = (byte) (f & 255);

        }

        return out;

    }

}