关于仅使用PGP公钥与密码短语解密PGP文件的可行性及Java实现方案咨询

阿华AIGC实验室

2026-4-22

嘿，咱们先把核心问题掰扯清楚：从PGP的加密设计逻辑来说，仅用公钥+密码短语解密文件是完全不可能的。

先给你理明白PGP加密的基本流程：当用PGP加密文件时，其实是分两步走的：

生成一个随机的对称会话密钥，用这个密钥加密实际的文件内容（对称加密效率高，适合大文件）；
用收件人的公钥加密这个会话密钥（非对称加密保证只有对应私钥的持有者能解开会话密钥）。

而解密流程刚好反过来：必须先用私钥解开加密后的会话密钥，再用这个会话密钥解密文件内容。这里的密码短语，其实是用来保护私钥本身的——私钥通常会被加密存储，需要密码短语才能解锁使用，它并不是直接用来解密文件的。

所以如果没有对应的私钥，哪怕你有公钥和密码短语，也根本无法获取解密文件所需的会话密钥，自然没法解密文件。这是PGP加密体系的核心安全机制，就是为了保证只有私钥持有者才能访问加密内容。

如果你确实需要正确解密PGP文件（必须有私钥）

如果是客户端搞混了公钥和私钥的用途，或者他们其实能提供私钥，那可以用Java结合BouncyCastle库来实现解密，这是Java生态里处理PGP最常用的工具库。

第一步：引入依赖（Maven为例）

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcpg-jdk15on</artifactId>
    <version>1.70</version>
</dependency>
<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcpkix-jdk15on</artifactId>
    <version>1.70</version>
</dependency>

第二步：解密代码示例

import org.bouncycastle.openpgp.*;
import org.bouncycastle.openpgp.jcajce.JcaPGPObjectFactory;
import org.bouncycastle.openpgp.operator.jcajce.JcaKeyFingerprintCalculator;
import org.bouncycastle.openpgp.operator.jcajce.JcePBESecretKeyDecryptorBuilder;
import org.bouncycastle.openpgp.operator.jcajce.JcePGPDataDecryptorFactoryBuilder;

import java.io.*;
import java.security.Security;
import java.util.Iterator;

public class PGPFileDecryptor {

    // 注册BouncyCastle安全提供者
    static {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
    }

    /**
     * PGP文件解密方法
     * @param inputFilePath 加密的PGP文件路径
     * @param privateKeyFilePath 私钥文件路径
     * @param passphrase 私钥的保护密码
     * @param outputFilePath 解密后输出的文件路径
     * @throws Exception 解密过程中可能抛出的异常
     */
    public static void decryptPGPFile(String inputFilePath, String privateKeyFilePath, String passphrase, String outputFilePath) throws Exception {
        // 打开加密文件和私钥文件流
        InputStream encryptedFileStream = new BufferedInputStream(new FileInputStream(inputFilePath));
        InputStream privateKeyStream = new BufferedInputStream(new FileInputStream(privateKeyFilePath));

        // 加载私钥环集合
        PGPSecretKeyRingCollection secretKeyRingCollection = new PGPSecretKeyRingCollection(
                PGPUtil.getDecoderStream(privateKeyStream), new JcaKeyFingerprintCalculator());
        privateKeyStream.close();

        // 解析加密数据
        JcaPGPObjectFactory pgpObjectFactory = new JcaPGPObjectFactory(PGPUtil.getDecoderStream(encryptedFileStream));
        Object firstObject = pgpObjectFactory.nextObject();
        PGPEncryptedDataList encryptedDataList;

        if (firstObject instanceof PGPEncryptedDataList) {
            encryptedDataList = (PGPEncryptedDataList) firstObject;
        } else {
            // 处理可能的嵌套结构
            encryptedDataList = (PGPEncryptedDataList) pgpObjectFactory.nextObject();
        }

        // 匹配对应的私钥
        Iterator<PGPEncryptedData> encryptedDataIterator = encryptedDataList.getEncryptedDataObjects();
        PGPPrivateKey privateKey = null;
        PGPPublicKeyEncryptedData publicKeyEncryptedData = null;

        while (privateKey == null && encryptedDataIterator.hasNext()) {
            publicKeyEncryptedData = (PGPPublicKeyEncryptedData) encryptedDataIterator.next();
            PGPSecretKey secretKey = secretKeyRingCollection.getSecretKey(publicKeyEncryptedData.getKeyID());
            if (secretKey != null) {
                // 用密码短语解锁私钥
                privateKey = secretKey.extractPrivateKey(
                        new JcePBESecretKeyDecryptorBuilder()
                                .setProvider("BC")
                                .build(passphrase.toCharArray())
                );
            }
        }

        if (privateKey == null) {
            throw new IllegalArgumentException("找不到与加密数据匹配的私钥，请检查私钥文件和密码");
        }

        // 解密获取明文数据流
        InputStream plainTextStream = publicKeyEncryptedData.getDataStream(
                new JcePGPDataDecryptorFactoryBuilder()
                        .setProvider("BC")
                        .build(privateKey)
        );

        // 处理可能的压缩数据
        JcaPGPObjectFactory plainObjectFactory = new JcaPGPObjectFactory(plainTextStream);
        Object messageObject = plainObjectFactory.nextObject();

        if (messageObject instanceof PGPCompressedData) {
            PGPCompressedData compressedData = (PGPCompressedData) messageObject;
            JcaPGPObjectFactory compressedObjectFactory = new JcaPGPObjectFactory(compressedData.getDataStream());
            messageObject = compressedObjectFactory.nextObject();
        }

        // 输出明文内容到文件
        if (messageObject instanceof PGPLiteralData) {
            PGPLiteralData literalData = (PGPLiteralData) messageObject;
            OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(outputFilePath));
            InputStream literalInputStream = literalData.getInputStream();
            int byteRead;
            while ((byteRead = literalInputStream.read()) != -1) {
                outputStream.write(byteRead);
            }
            outputStream.close();
        } else {
            throw new IllegalArgumentException("加密文件不是明文数据类型，无法直接解密");
        }

        // 验证完整性（如果加密时开启了完整性保护）
        if (publicKeyEncryptedData.isIntegrityProtected() && !publicKeyEncryptedData.verify()) {
            throw new IllegalArgumentException("解密后的文件完整性验证失败，可能被篡改");
        }

        encryptedFileStream.close();
    }

    // 测试示例
    public static void main(String[] args) {
        try {
            decryptPGPFile("encrypted_file.pgp", "private_key.asc", "your_passphrase", "decrypted_file.txt");
            System.out.println("解密完成！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}