Java PBKDF2密钥派生到前端JavaScript的转换指南

import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

public class SecurityPasswordEncoder {

    private SecretKeyFactory factory;
    private final char[] hexArray = "0123456789ABCDEF".toCharArray();

    public SecurityPasswordEncoder() throws NoSuchAlgorithmException {
        // 初始化SecretKeyFactory，指定算法为PBKDF2WithHmacSHA1
        this.factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
    }

    public boolean matches(String rawPassword, String encodedPassword, String salt) throws InvalidKeySpecException {
        // 将十六进制字符串盐值转换为字节数组
        byte[] osalt = hexStringToByteArray(salt);
        // 定义一个32字节的数组来存储派生密钥的前32字节
        byte[] oValidate = new byte[32];

        // 创建PBEKeySpec，包含原始密码、盐值、迭代次数和密钥长度
        // 10000为迭代次数，384为期望的密钥位长度 (48字节)
        PBEKeySpec pbeKeySpec = new PBEKeySpec(rawPassword.toCharArray(), osalt, 10000, 384);
        // 生成秘密密钥
        Key secretKey = this.factory.generateSecret(pbeKeySpec);
        // 从生成的密钥中复制前32字节到oValidate数组
        System.arraycopy(secretKey.getEncoded(), 0, oValidate, 0, 32);
        // 将派生出的32字节密钥转换为十六进制字符串
        String sValidate = byteArrayToHexString(oValidate);
        // 比较派生密钥与提供的编码密码是否一致
        return (sValidate.equals(encodedPassword));
    }

    // 辅助函数：将十六进制字符串转换为字节数组
    private byte[] hexStringToByteArray(String s) {
        byte[] b = new byte[s.length() / 2];
        for (int i = 0; i < b.length; i++) {
            int index = i * 2;
            int v = Integer.parseInt(s.substring(index, index + 2), 16);
            b[i] = (byte) v;
        }
        return b;
    }

    // 辅助函数：将字节数组转换为十六进制字符串
    private String byteArrayToHexString(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);
    }
}

/**
 * 将十六进制字符串转换为ArrayBuffer
 * @param {string} hex - 十六进制字符串
 * @returns {Uint8Array} - 对应的Uint8Array
 */
const hex2ab = hex => new Uint8Array(hex.match(/[\da-f]{2}/gi).map((x) => parseInt(x, 16)));

/**
 * 将ArrayBuffer转换为十六进制字符串
 * @param {ArrayBuffer} ab - ArrayBuffer
 * @returns {string} - 对应的十六进制字符串
 */
const ab2hex = ab => Array.prototype.map.call(new Uint8Array(ab), x => ('00' + x.toString(16)).slice(-2)).join('');

/**
 * 使用PBKDF2派生密钥
 * @param {string} password - 原始密码
 * @param {string} salt - 十六进制编码的盐值
 * @param {number} iterations - 迭代次数
 * @param {string} hash - 哈希算法 (例如 "SHA-1", "SHA-256")
 * @returns {Promise<string>} - 返回派生密钥的十六进制字符串表示
 */
function deriveAKey(password, salt, iterations, hash) {
    // 1. 导入密码作为PBKDF2的基础密钥
    return window.crypto.subtle.importKey(
        "raw", // 密钥格式为原始字节
        new TextEncoder().encode(password), // 将密码字符串编码为UTF-8字节
        {name: "PBKDF2"}, // 密钥算法为PBKDF2
        false, // 不可导出
        ["deriveKey"] // 允许用于派生其他密钥
    )
    .then(function(baseKey){
        // 2. 从基础密钥派生目标密钥
        return window.crypto.subtle.deriveKey(
            {
                name: "PBKDF2",
                salt: hex2ab(salt), // 将十六进制盐值转换为ArrayBuffer
                iterations: iterations, // 迭代次数
                hash: hash // PBKDF2使用的哈希算法
            },
            baseKey, // 基础密钥
            {name:"HMAC", hash: hash, length: 256}, // 目标密钥算法：HMAC，哈希算法与PBKDF2一致，长度指定为256位（32字节）
            true, // 可导出
            ["sign", "verify"] // 允许用于签名和验证（取决于实际需求，此处为示例）
        );
    })
    .then(function(aesKey) {
        // 3. 导出派生出的密钥的原始字节
        return window.crypto.subtle.exportKey("raw", aesKey);
    })
    .then(function(keyBytes) {
        // 4. 将密钥字节转换为大写的十六进制字符串并返回
        return ab2hex(keyBytes).toUpperCase();
    })
    .catch(function(err) {
        console.error("密钥派生失败: " + err.message);
        throw err; // 抛出错误以便上层处理
    });
}

// 假设SecurityPasswordEncoder已实例化
SecurityPasswordEncoder encoder = new SecurityPasswordEncoder();
boolean match = encoder.matches("my passphrase", "85CE92FBA21475DF45CB742576A3356A9E2B0011AC084611814E4E282880245E", "01020304abacadae");
System.out.println("Java match result: " + match); // 预期输出 true

deriveAKey("my passphrase", "01020304abacadae", 10000, "SHA-1")
    .then(derivedKeyHex => {
        console.log("JavaScript derived key:", derivedKeyHex);
        // 预期输出: "85CE92FBA21475DF45CB742576A3356A9E2B0011AC084611814E4E282880245E"
        const expectedKey = "85CE92FBA21475DF45CB742576A3356A9E2B0011AC084611814E4E282880245E";
        console.log("JavaScript match result:", derivedKeyHex === expectedKey); // 预期输出 true
    })
    .catch(error => {
        console.error("密钥派生过程中发生错误:", error);
    });