PHP与Java AES/GCM/128加解密互操作指南

1. AES/GCM跨语言加解密概述

在现代应用开发中，不同编程语言之间的数据安全交换是常见的需求。AES/GCM（Advanced Encryption Standard / Galois/Counter Mode）是一种推荐的认证加密模式，它不仅提供数据保密性，还提供数据完整性和认证性。然而，在PHP和Java等不同平台间实现AES/GCM的互操作性，需要严格遵循相同的加密参数、密钥处理、IV（Initialization Vector）生成、认证标签（Authentication Tag）长度以及数据编码/解码规范。任何细微的不一致都可能导致解密失败，通常表现为Java端的AEADBadTagException。

2. PHP加密逻辑分析

首先，我们来分析PHP端的加密实现，这是理解Java端如何正确解密的基础。PHP的aes_gcm_encrypt函数定义了加密过程：

 $encryptStr \n");
?>

关键点总结：

• 算法选择： aes-128-gcm，这意味着AES密钥长度为128位（16字节），GCM模式。
• 密钥处理： $secret是一个十六进制字符串，通过hex2bin($secret)直接转换为二进制密钥。
• IV生成： openssl_random_pseudo_bytes(openssl_cipher_iv_length($cipher))生成随机IV。对于AES-128-GCM，IV长度通常是12字节（96位）。
• 认证标签： $tag由openssl_encrypt函数自动生成，对于GCM模式，默认标签长度为16字节（128位）。
• 输出格式： 这是最关键的一步。PHP将IV、密文和认证标签的二进制数据分别转换为十六进制字符串，然后将这三个十六进制字符串拼接起来。最后，将这个完整的十六进制字符串再转换回二进制数据，并进行Base64编码输出。

PHP的解密函数aes_gcm_decrypt也印证了这一编码方式：

从PHP解密逻辑中我们可以明确：

1. IV的十六进制表示长度为24，对应12字节。
2. Tag的十六进制表示长度为32，对应16字节。
3. 加密输出的Base64解码后，得到的二进制数据流实际上是 IV的二进制 + 密文的二进制 + Tag的二进制。

3. Java端解密实现与问题分析

最初的Java解密尝试遭遇了AEADBadTagException，这通常意味着密钥、IV、认证标签或密文在解密时存在不匹配。

import java.security.spec.KeySpec;
import java.util.Base64;
import java.util.Random; // 注意：这里使用了Random生成salt
import javax.crypto.*;
import javax.crypto.spec.*;

public class MyTest {

    // ... main 方法 ...

    private static String decrypt(String data, String mainKey, int ivLength) throws Exception {
        final byte[] encryptedBytes = Base64.getDecoder().decode(data.getBytes("UTF8"));
        final byte[] initializationVector = new byte[ivLength]; // IV长度问题
        System.arraycopy(encryptedBytes, 0, initializationVector, 0, ivLength);

        // 密钥生成方式与PHP不一致
        SecretKeySpec secretKeySpec = new SecretKeySpec(generateSecretKeyFromPassword(mainKey, mainKey.length()), "AES");

        GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, initializationVector);
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, gcmParameterSpec);

        // 密文和Tag的提取方式
        return new String(cipher.doFinal(encryptedBytes, ivLength, encryptedBytes.length - ivLength), "UTF8");
    }

    // 错误的密钥生成方法
    private static byte[] generateSecretKeyFromPassword(String password, int keyLength) throws Exception {
        byte[] salt = new byte[keyLength];
        new Random(password.hashCode()).nextBytes(salt);
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 65536, 128);
        return factory.generateSecret(spec).getEncoded();
    }
}

问题分析：

1. 密钥生成不匹配： PHP直接将十六进制字符串转换为二进制作为密钥，而Java尝试使用PBKDF2WithHmacSHA256从密码派生密钥。这两种密钥生成方式完全不同，导致密钥不匹配。
2. IV长度不正确： PHP的AES-128-GCM使用12字节（96位）的IV，而Java代码中ivLength被硬编码为16。
3. 数据解析理解： 虽然Java代码的cipher.doFinal(encryptedBytes, ivLength, encryptedBytes.length - ivLength)逻辑上是正确的，它将Base64解码后的数据分为IV和“密文+Tag”两部分，但由于IV长度和密钥的错误，导致了整体失败。

4. 正确的Java解密实现

为了与PHP的加密行为完全兼容，Java端的解密代码需要进行以下修正：

1. 密钥处理： 必须将PHP的十六进制密钥字符串转换为字节数组，而不是通过PBKDF2派生。
2. IV长度： 明确指定IV长度为12字节。
3. 数据解析： 确保Base64解码后的数据流正确地分割出IV，并将剩余部分（密文和认证标签）传递给Cipher.doFinal。

以下是修正后的Java解密代码：

import java.nio.charset.StandardCharsets;
import java.util.Base64;
import javax.crypto.*;
import javax.crypto.spec.*;

public class MyTest {

    public static final String ALGO = "AES"; // 算法名称
    public static final String GCM_ALGO = "AES/GCM/NoPadding"; // GCM模式，不填充
    public static final int IV_LENGTH = 12; // IV长度：12字节 (96位)

    public static void main(String[] args) throws Exception {
        String secret = "544553544B4559313233343536"; // PHP提供的十六进制密钥
        String encryptStr = "Fun3yZTPcHsxBpft+jBZDe2NjGNAs8xUHY21eZswZE4iLKYdBsyER7RwVfFvuQ=="; // PHP加密结果

        // 格式化密钥，确保其长度为32个十六进制字符（16字节）
        secret = reformatSecret(secret); 

        String decryptStr = decrypt(encryptStr, secret);
        System.out.println("encryptString: " + encryptStr);
        System.out.println("secret: " + secret);
        System.out.println("decryptString: " + decryptStr);
    }

    /**
     * 解密PHP加密的数据
     * @param data Base64编码的加密字符串
     * @param secret 十六进制格式的密钥
     * @return 解密后的原始字符串
     * @throws Exception 
     */
    private static String decrypt(String data, String secret) throws Exception {
        // 1. Base64解码加密数据
        final byte[] encryptedBytes = Base64.getDecoder().decode(data.getBytes(StandardCharsets.UTF_8));

        // 2. 提取IV
        final byte[] initializationVector = new byte[IV_LENGTH];
        System.arraycopy(encryptedBytes, 0, initializationVector, 0, IV_LENGTH);

        // 3. 将十六进制密钥字符串转换为字节数组
        final byte[] key = parseHexStr2Byte(secret);

        // 4. 创建SecretKeySpec
        SecretKeySpec secretKeySpec = new SecretKeySpec(key, ALGO);

        // 5. 创建GCMParameterSpec，GCM模式默认Tag长度为128位（16字节）
        GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, initializationVector);

        // 6. 初始化Cipher为解密模式
        Cipher cipher = Cipher.getInstance(GCM_ALGO);
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, gcmParameterSpec);

        // 7. 执行解密：从IV之后开始，直到数据末尾，包含密文和Tag
        return new String(cipher.doFinal(encryptedBytes, IV_LENGTH, encryptedBytes.length - IV_LENGTH), StandardCharsets.UTF_8);
    }

    /**
     * 格式化密钥字符串，使其长度为32个十六进制字符（对应16字节）
     * 如果不足32位，则补零；如果超过32位，则截断。
     * @param secret 原始十六进制密钥字符串
     * @return 格式化后的32位十六进制密钥字符串
     */
    public static String reformatSecret(String secret) {
        if (secret == null || secret.length() < 1) {
            return "";
        }
        int secretLen = secret.length();
        if (secretLen < 32) {
            StringBuilder str = new StringBuilder(secret);
            while (secretLen < 32) {
                str.append("0"); // 补零
                secretLen = str.length();
            }
            return str.toString();
        } else {
            return secret.substring(0, 32); // 截断
        }
    }

    /**
     * 将十六进制字符串转换为字节数组
     * @param hexStr 十六进制字符串
     * @return 对应的字节数组
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        int len = hexStr.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(hexStr.charAt(i), 16) << 4) + Character.digit(hexStr.charAt(i+1), 16));
        }
        return data;
    }
}

5. 注意事项与最佳实践

1. 参数一致性： 跨语言加解密的核心在于所有加密参数（算法、模式、密钥、IV、认证标签长度）必须严格一致。
2. 密钥管理： 示例中的密钥直接硬编码在代码中，这在生产环境中是不安全的做法。应使用安全的密钥管理方案，如环境变量、密钥管理服务或安全配置文件。
3. IV的唯一性： GCM模式对IV的唯一性有严格要求，每次加密都必须使用不同的、不可预测的IV。PHP的openssl_random_pseudo_bytes可以满足此要求。Java端解密时，IV是从加密数据中提取的。
4. 认证标签： GCM模式的认证标签（默认为128位/16字节）是确保数据完整性和认证性的关键。AEADBadTagException通常是由于IV、密钥或密文被篡改或不匹配导致的。
5. 字符编码： 在进行字符串与字节数组转换时，务必指定统一的字符编码（如StandardCharsets.UTF_8），以避免乱码问题。
6. 数据格式： 明确加密数据的输出格式（本例中是Base64编码的`IV_