React Native Kotlin Turbo模块大文件AES-GCM解密失败求助

环境信息 #

• 平台： React Native（Android）
• 模块类型： Turbo Module
• 加密方式： AES-GCM（使用32字节密钥）
• 开发语言： Kotlin（Turbo模块）、Python（测试用）
• 文件大小：
  • 小文件（约10MB）：解密成功 ✅
  • 大文件（约25MB）：解密失败，抛出AEADBadTagException ❌

问题描述 #

我为React Native Android应用实现了自定义Turbo模块的文件加解密功能，小文件（约10MB）解密完全正常，但大文件（约25MB）解密时会抛出AEADBadTagException异常。不同文件大小使用的密钥和IV完全一致，这种情况超出预期，恳请各位提供问题原因分析及解决方案。

观察到的行为 #

• 小文件（10MB）： 解密成功完成。
• 大文件（25MB）： 解密失败，触发AEADBadTagException。

解密失败时的诊断日志如下：

IV Hex: 143CEBC57F8D2D6BC00BB8D2  
IV Base64: FDzrxX+NLWvAC7jS  
Key Base64: GVdyBd3JD4gAaFZeBVLEJHOdULsIIhc9lITsSWBF36Y=  
Key Length: 32 bytes

Kotlin解密实现代码 #

private fun decryptInputStreamAES_GCM(
    inputStream: InputStream,
    outputStream: OutputStream,
    key: SecretKey
): String {
    val startTime = System.nanoTime()
    
    try {
        // Read IV from the input stream
        val iv = ByteArray(12)
        var totalIvBytesRead = 0
        while (totalIvBytesRead < 12) {
            val bytesRead = inputStream.read(iv, totalIvBytesRead, 12 - totalIvBytesRead)
            if (bytesRead == -1) {
                throw IllegalStateException("Incomplete IV: Only read $totalIvBytesRead bytes")
            }
            totalIvBytesRead += bytesRead
        }

        // Logging IV and Key
        val ivHex = iv.joinToString("") { "%02X".format(it) }
        val ivBase64 = Base64.encodeToString(iv, Base64.NO_WRAP)
        val keyBase64 = Base64.encodeToString(key.encoded, Base64.NO_WRAP)
        
        // Initialize cipher
        val cipher = Cipher.getInstance("AES/GCM/NoPadding")
        val gcmParams = GCMParameterSpec(128, iv)
        cipher.init(Cipher.DECRYPT_MODE, key, gcmParams)

        // Adaptive buffering
        val inputBufferSize = 32768  // 32KB buffer
        val inputBuffer = ByteArray(inputBufferSize)
        val outputBuffer = ByteArray(inputBufferSize + cipher.blockSize)
        
        var totalBytesDecrypted = 0L
        var bytesRead: Int

        // Decrypting in chunks
        while (inputStream.read(inputBuffer).also { bytesRead = it } != -1) {
            val outputSize = cipher.update(inputBuffer, 0, bytesRead, outputBuffer, 0)
            if (outputSize > 0) {
                outputStream.write(outputBuffer, 0, outputSize)
                totalBytesDecrypted += outputSize
            }
        }

        // Final block processing
        val finalOutputBuffer = ByteArray(cipher.getOutputSize(0))
        val finalBlockSize = cipher.doFinal(finalOutputBuffer, 0)
        
        if (finalBlockSize > 0) {
            outputStream.write(finalOutputBuffer, 0, finalBlockSize)
            totalBytesDecrypted += finalBlockSize
        }

        return JSONObject().apply {
            put("decryptedLength", totalBytesDecrypted)
        }.toString()
    } catch (e: Exception) {
        Log.e("Decryption", "Error", e)
        throw e
    }
}

问题咨询 #

1. 大文件解密失败的原因是什么？
   既然相同密钥和IV对小文件有效，是否存在缓冲区管理、流处理或AES-GCM大数据处理的问题？

2. 该实现中AES-GCM处理大文件是否存在已知限制？
   AEADBadTagException是否由认证标签处理错误或缓冲区溢出导致？

3. 如何修改解密流程以适配所有文件大小？
   是否有调整缓冲区大小、优化cipher.update处理或修改流处理方式等最佳实践来避免该异常？

已执行的调试步骤 #

• 不同文件大小使用的密钥和IV完全一致。
• 已测试多种缓冲区大小，但问题仍存在。
• 已验证文件完整性，确保加解密过程无数据损坏。
• 加解密逻辑不随文件大小变化，保持统一。

补充验证：Python解密测试 #

为交叉验证，我使用以下Python脚本成功解密了相同文件：

from Crypto.Cipher import AES
import base64

def decrypt_gcm(encrypted_file_path, output_file_path, key_base64, iv_base64):
    # Decode key and IV
    key = base64.b64decode(key_base64)
    iv = base64.b64decode(iv_base64)

    # Read encrypted file
    with open(encrypted_file_path, 'rb') as f:
        # Skip first 12 bytes (IV)
        f.read(12)
        ciphertext = f.read()

    # Create cipher
    cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
    
    try:
        # Decrypt
        decrypted_data = cipher.decrypt(ciphertext)
        
        # Write decrypted data
        with open(output_file_path, 'wb') as f:
            f.write(decrypted_data)
        
        print("Decryption successful!")
    except Exception as e:
        print(f"Decryption failed: {e}")

# Usage
decrypt_gcm("encrypted.enc", "decrypted.mp4", 
            "gS8q4a8B2hJ9yVKIl7F0ril6GMzthZHHCRXVQ6rI854=", 
            "IJidrs9f55XaYgHJ")

可确认：

• 密钥和IV完全正确。
• 从文件中提取的IV长度和值符合预期。
• Python中解密成功，说明问题大概率出在Kotlin实现中。

恳请各位提供指导、分析或解决方案，非常感谢！

问题分析与解决方案 #

原因分析

1. 认证标签处理逻辑错误：AES-GCM加密的文件结构为IV(12字节) + 密文 + 认证标签(16字节)，原Kotlin代码将包含认证标签的所有数据通过cipher.update()处理，最后调用cipher.doFinal(finalOutputBuffer, 0)处理空输入。这导致认证标签被当成密文的一部分解析，而未被提交给Cipher进行验证，触发AEADBadTagException。
2. 小文件偶然成功的原因：小文件的密文+标签总长度刚好适配缓冲区大小，部分Android系统的Cipher实现可能在这种场景下进行了容错处理，但这不符合规范，大文件的分块处理打破了这种容错，导致异常暴露。

解决方案

使用Android提供的CipherInputStream自动处理解密流和认证标签验证，避免手动分块处理的错误。修改后的代码如下：

private fun decryptInputStreamAES_GCM(
    inputStream: InputStream,
    outputStream: OutputStream,
    key: SecretKey
): String {
    val startTime = System.nanoTime()
    
    try {
        // Read IV from the input stream
        val iv = ByteArray(12)
        var totalIvBytesRead = 0
        while (totalIvBytesRead < 12) {
            val bytesRead = inputStream.read(iv, totalIvBytesRead, 12 - totalIvBytesRead)
            if (bytesRead == -1) {
                throw IllegalStateException("Incomplete IV: Only read $totalIvBytesRead bytes")
            }
            totalIvBytesRead += bytesRead
        }

        // Logging IV and Key
        val ivHex = iv.joinToString("") { "%02X".format(it) }
        val ivBase64 = Base64.encodeToString(iv, Base64.NO_WRAP)
        val keyBase64 = Base64.encodeToString(key.encoded, Base64.NO_WRAP)
        Log.d("Decryption", "IV Hex: $ivHex\nIV Base64: $ivBase64\nKey Base64: $keyBase64\nKey Length: ${key.encoded.size} bytes")
        
        // Initialize cipher
        val cipher = Cipher.getInstance("AES/GCM/NoPadding")
        val gcmParams = GCMParameterSpec(128, iv)
        cipher.init(Cipher.DECRYPT_MODE, key, gcmParams)

        // 使用CipherInputStream自动处理解密与标签验证
        CipherInputStream(inputStream, cipher).use { cis ->
            val buffer = ByteArray(32768)
            var bytesRead: Int
            var totalBytesDecrypted = 0L
            while (cis.read(buffer).also { bytesRead = it } != -1) {
                outputStream.write(buffer, 0, bytesRead)
                totalBytesDecrypted += bytesRead
            }
            outputStream.flush()
            
            return JSONObject().apply {
                put("decryptedLength", totalBytesDecrypted)
            }.toString()
        }
    } catch (e: Exception) {
        Log.e("Decryption", "Error", e)
        throw e
    }
}

关键改进点

• CipherInputStream会自动处理密文与认证标签的分离，在流读取结束时完成标签验证，无需手动调用doFinal处理标签。
• 简化了流处理逻辑，避免手动缓冲区管理可能带来的错误。
• 保持了原有的IV读取逻辑和日志输出，确保兼容性。

内容的提问来源于stack exchange，提问作者TheGuy