加密与安全_PGP、OpenPGP和GPG加密通信协议

已于 2024-03-09 04:12:44 修改
阅读量4.7k 收藏 12
点赞数 35
分类专栏： 【安全攻防】 文章标签： 安全 java PGP OpenPGP GPG
于 2024-03-09 04:11:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshangwei/article/details/136565584
版权

文章目录


在这里插入图片描述

PGP

PGP (Pretty Good Privacy) 是一种加密通信协议，用于保护电子邮件和文件的安全性和隐私。它通过使用加密、数字签名和压缩技术来确保数据的保密性、完整性和可验证性。

GP最初由麻省理工学院的Nick embrace和Eric Hughes开发，后来由Phil Zimmermann进一步发展。它使用公钥加密和私钥解密的机制，以确保只有信息的接收者才能解密和阅读邮件内容。

PGP的主要优点是它易于使用，并能在大多数流行的电子邮件客户端中集成。然而，随着更高级的加密技术和标准（如OpenPGP和GPG）的出现，PGP已经在一定程度上被这些新标准取代。

PGP不仅仅用于电子邮件，它也可以用于加密文件和数据。

  1. 加密和解密: PGP 使用对称加密和非对称加密相结合的方式来实现加密和解密。发送方使用接收方的公钥对消息进行加密，接收方使用自己的私钥对消息进行解密。此外，PGP 还支持对数据进行数字签名，以确保数据的完整性和验证发送方的身份。

  2. 密钥管理: PGP 使用密钥对来管理加密和解密过程。每个用户都有一个公钥和一个私钥。公钥用于加密消息，私钥用于解密消息。这些密钥对可以通过密钥服务器或密钥交换方式获取。

  3. 数字签名: PGP 允许用户使用自己的私钥对消息进行数字签名。接收方可以使用发送方的公钥验证签名，以确保消息的完整性和发送方的身份。

  4. 信任模型: PGP 使用基于信任的模型来验证密钥的真实性。用户可以通过直接交换密钥、使用信任链或通过信任服务器来建立信任。

  5. 开放标准: PGP 是一种开放标准，意味着任何人都可以实现和使用该协议，而不受限于特定的厂商或供应商。

总的来说，PGP 是一种强大的加密协议，用于保护通信内容的机密性和完整性，同时提供身份验证机制。它广泛用于电子邮件和文件加密，以确保用户的数据安全和隐私。

OpenPGP和GPG（GNU Privacy Guard）是PGP（Pretty Good Privacy）的开放标准和自由软件实现。 随着时间的推移，PGP的标准和实现逐渐演进，OpenPGP和GPG就是其中的两个重要发展。

OpenPGP

OpenPGP是一个开放标准，它定义了一种用于加密和数字签名数据的协议。这个标准允许不同的加密软件相互兼容，这意味着使用不同OpenPGP实现的用户可以安全地交换加密信息。OpenPGP标准是由RFC 4880定义的，它包括了公钥和私钥的生成、交换和验证方法，以及加密和签名的算法。

GPG

GPG是OpenPGP的一个流行实现，它是GNU项目的一部分，由GNU通用公共许可证（GPL）发布。GPG是一个命令行工具，可以在多种操作系统中运行，包括Linux、macOS和Windows。GPG提供了创建和验证数字签名、加密文件和电子邮件以及安全地交换密钥等功能。

GPG的核心组件包括：

  • keyring：用于存储公钥和私钥。
  • gpg：命令行工具，用于执行加密、解密、签名和验证等操作。
  • gpgconf：用于配置GPG的命令行工具。
  • gpg-agent：一个守护进程，用于提供密钥管理、加密和服务器功能。

GPG的使用场景包括：

  • 安全地交换电子邮件和文件。
  • 验证软件的完整性和来源。
  • 保护个人隐私和商业机密。

工作原理

PGP（Pretty Good Privacy）涉及加密、数字签名和密钥管理等关键步骤

在这里插入图片描述

  1. 密钥生成: 用户生成一对公钥和私钥。公钥用于加密消息，私钥用于解密消息和生成数字签名。

  2. 加密: 发送方使用接收方的公钥来加密消息。这样，只有拥有相应私钥的接收方才能解密消息。

  3. 数字签名: 发送方使用自己的私钥对消息进行签名。接收方使用发送方的公钥验证签名，确保消息的完整性和发送方的身份。

  4. 密钥管理: 用户可以通过密钥服务器或直接交换密钥的方式来管理和共享公钥。

工作流程

  1. 密钥交换: 发送方和接收方需要交换公钥。这可以通过密钥服务器、直接交换或其他安全渠道完成。

  2. 加密消息:

    • 发送方选择要发送的消息，并使用接收方的公钥对消息进行加密。
    • 发送方可以选择使用对称加密算法来加密消息内容，然后再使用接收方的公钥来加密对称密钥，这样可以提高效率。
    • 发送方发送加密后的消息给接收方。

  3. 解密消息:

    • 接收方使用自己的私钥解密接收到的消息。
    • 如果消息有数字签名，接收方使用发送方的公钥验证签名。

  4. 数字签名验证:

    • 接收方使用发送方的公钥验证数字签名，确保消息的完整性和发送方的身份。

  5. 信任管理:

    • 用户可以建立信任关系，以确保使用其他用户的公钥时其真实性。
    • 信任关系可以通过直接交换密钥、信任链或信任服务器来建立。

总的来说，PGP的工作原理涉及加密、数字签名和密钥管理，通过这些步骤保证了消息的机密性、完整性和可验证性。

用途

在这里插入图片描述

PGP 本质上有三个主要用途：

  • 发送和接收加密电子邮件。
  • 验证向你发送消息的人的身份。
  • 加密文件。

案例说明

假设Alice和Bob是两个使用PGP加密通信的用户。他们希望通过电子邮件进行安全通信，以保护其消息的机密性和完整性。

过程

  1. 密钥生成:

    • Alice 和 Bob 分别生成一对公钥和私钥。

  2. 密钥交换:

    • Alice 将她的公钥发送给 Bob，而 Bob 也将他的公钥发送给 Alice。这可以通过安全的电子邮件或其他安全通道完成。

  3. 加密消息:

    • Alice 决定向 Bob 发送一封加密的电子邮件。
    • Alice 使用 Bob 的公钥将邮件内容进行加密。
    • Alice 还可以选择使用对称加密算法来加密邮件内容，然后再使用 Bob 的公钥来加密对称密钥，以提高效率。

  4. 解密消息:

    • Bob 收到 Alice 发送的加密邮件后，使用自己的私钥解密邮件内容。
    • 如果邮件有数字签名，Bob 使用 Alice 的公钥验证签名，确保邮件的完整性和 Alice 的身份。

  5. 数字签名验证:

    • 如果 Alice 在邮件中添加了数字签名，Bob 使用 Alice 的公钥验证签名，以确保邮件的完整性和 Alice 的身份。

  6. 信任管理:

    • Alice 和 Bob 可能通过直接交换公钥或使用信任服务器来建立信任关系，以确保对方公钥的真实性。

在这个案例中，Alice 和 Bob 使用PGP协议加密和解密他们之间的通信，同时还可以使用数字签名来确保消息的完整性和验证发送方的身份。通过这种方式，他们可以安全地交换信息，而不用担心被未经授权的第三方窃取或篡改。

代码实现

在Java中完全实现PGP协议需要使用第三方库，因为PGP是一个复杂的加密协议。常用的库之一是Bouncy Castle.

在这里插入图片描述

pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.artisan</groupId>
    <artifactId>pgp-encryption</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on -->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcpg-jdk15on</artifactId>
            <version>1.70</version>
            <scope>compile</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.bouncycastle/bcpkix-jdk15on -->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcpkix-jdk15on</artifactId>
            <version>1.70</version>
            <scope>compile</scope>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.11.0</version>
        </dependency>

    </dependencies>


</project>

PgpEncryptionUtil

package com.artisan.pgpUtils;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import org.apache.commons.io.IOUtils;
import org.bouncycastle.bcpg.ArmoredOutputStream;
import org.bouncycastle.bcpg.CompressionAlgorithmTags;
import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.openpgp.PGPCompressedDataGenerator;
import org.bouncycastle.openpgp.PGPEncryptedDataGenerator;
import org.bouncycastle.openpgp.PGPException;
import org.bouncycastle.openpgp.operator.jcajce.JcePGPDataEncryptorBuilder;
import org.bouncycastle.openpgp.operator.jcajce.JcePublicKeyKeyEncryptionMethodGenerator;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.security.SecureRandom;
import java.security.Security;
import java.util.Objects;

/**
 * @author artisan
 */
@Getter
@Builder
@AllArgsConstructor
public class PgpEncryptionUtil {

    /**
     * 将Bouncy Castle添加到JVM中
     */
    static {
        // 将Bouncy Castle添加到JVM中
        if (Objects.isNull(Security.getProvider(BouncyCastleProvider.PROVIDER_NAME))) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    /**
     * 压缩算法，默认为ZIP
     */
    @Builder.Default
    private int compressionAlgorithm = CompressionAlgorithmTags.ZIP;

    /**
     * 对称密钥算法，默认为AES-128
     */
    @Builder.Default
    private int symmetricKeyAlgorithm = SymmetricKeyAlgorithmTags.AES_128;

    /**
     * 是否启用ASCII Armor，默认为true
     */
    @Builder.Default
    private boolean armor = true;


    /**
     * 是否启用完整性检查，默认为true
     */
    @Builder.Default
    private boolean withIntegrityCheck = true;

    /**
     * 缓冲区大小，默认为65536字节
     */
    @Builder.Default
    private int bufferSize = 1 << 16;

    /**
     * 加密方法，将明文数据使用公钥进行加密
     *
     * @param encryptOut
     * @param clearIn
     * @param length
     * @param publicKeyIn
     * @throws IOException
     * @throws PGPException
     */
    public void encrypt(OutputStream encryptOut, InputStream clearIn, long length, InputStream publicKeyIn)
            throws IOException, PGPException {
        // 创建压缩数据生成器
        PGPCompressedDataGenerator compressedDataGenerator =
                new PGPCompressedDataGenerator(compressionAlgorithm);
        // 创建PGP加密数据生成器
        PGPEncryptedDataGenerator pgpEncryptedDataGenerator = new PGPEncryptedDataGenerator(
                // 配置加密数据生成器
                new JcePGPDataEncryptorBuilder(symmetricKeyAlgorithm)
                        .setWithIntegrityPacket(withIntegrityCheck)
                        .setSecureRandom(new SecureRandom())
                        .setProvider(BouncyCastleProvider.PROVIDER_NAME)
        );
        // 添加公钥
        pgpEncryptedDataGenerator.addMethod(new JcePublicKeyKeyEncryptionMethodGenerator(
                CommonUtils.getPublicKey(publicKeyIn)));
        // 如果启用ASCII Armor，则创建ArmoredOutputStream
        if (armor) {
            encryptOut = new ArmoredOutputStream(encryptOut);
        }
        // 打开加密输出流
        OutputStream cipherOutStream = pgpEncryptedDataGenerator.open(encryptOut, new byte[bufferSize]);
        // 将压缩数据生成器打开，并将明文数据以字面形式复制到加密输出流中
        CommonUtils.copyAsLiteralData(compressedDataGenerator.open(cipherOutStream), clearIn, length, bufferSize);
        // 依次关闭所有输出流
        compressedDataGenerator.close();
        cipherOutStream.close();
        encryptOut.close();
    }

    /**
     * 加密方法，返回加密后的字节数组
     *
     * @param clearData
     * @param pubicKeyIn
     * @return
     * @throws PGPException
     * @throws IOException
     */
    public byte[] encrypt(byte[] clearData, InputStream pubicKeyIn) throws PGPException, IOException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(clearData);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        encrypt(outputStream, inputStream, clearData.length, pubicKeyIn);
        return outputStream.toByteArray();
    }

    // 加密方法，返回加密后的输入流
    public InputStream encrypt(InputStream clearIn, long length, InputStream publicKeyIn)
            throws IOException, PGPException {
        File tempFile = File.createTempFile("pgp-", "-encrypted");
        encrypt(Files.newOutputStream(tempFile.toPath()), clearIn, length, publicKeyIn);
        return Files.newInputStream(tempFile.toPath());
    }

    /**
     * 加密方法，将明文数据使用公钥字符串进行加密
     *
     * @param clearData
     * @param publicKeyStr
     * @return
     * @throws PGPException
     * @throws IOException
     */
    public byte[] encrypt(byte[] clearData, String publicKeyStr) throws PGPException, IOException {
        return encrypt(clearData, IOUtils.toInputStream(publicKeyStr, Charset.defaultCharset()));
    }

    /**
     * 加密方法，返回加密后的输入流
     *
     * @param clearIn
     * @param length
     * @param publicKeyStr
     * @return
     * @throws IOException
     * @throws PGPException
     */
    public InputStream encrypt(InputStream clearIn, long length, String publicKeyStr) throws IOException, PGPException {
        return encrypt(clearIn, length, IOUtils.toInputStream(publicKeyStr, Charset.defaultCharset()));
    }
}

PgpDecryptionUtil

 package com.artisan.pgpUtils;

import org.apache.commons.io.IOUtils;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.openpgp.PGPEncryptedData;
import org.bouncycastle.openpgp.PGPEncryptedDataList;
import org.bouncycastle.openpgp.PGPException;
import org.bouncycastle.openpgp.PGPPrivateKey;
import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData;
import org.bouncycastle.openpgp.PGPSecretKey;
import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
import org.bouncycastle.openpgp.PGPUtil;
import org.bouncycastle.openpgp.jcajce.JcaPGPObjectFactory;
import org.bouncycastle.openpgp.operator.jcajce.JcaKeyFingerprintCalculator;
import org.bouncycastle.openpgp.operator.jcajce.JcePBESecretKeyDecryptorBuilder;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.security.Security;
import java.util.Iterator;
import java.util.Objects;

/**
 * @author artisan
 */
public class PgpDecryptionUtil {

    static {
        // 将Bouncy Castle添加到JVM中
        if (Objects.isNull(Security.getProvider(BouncyCastleProvider.PROVIDER_NAME))) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    /**
     * 私钥密码
     */
    private final char[] passCode;

    /**
     * 密钥环集合
     */
    private final PGPSecretKeyRingCollection pgpSecretKeyRingCollection;

    /**
     * @param privateKeyIn
     * @param passCode
     * @throws IOException
     * @throws PGPException
     */
    public PgpDecryptionUtil(InputStream privateKeyIn, String passCode) throws IOException, PGPException {
        this.passCode = passCode.toCharArray(); // 将密码转换为字符数组
        // 从输入流中读取PGP密钥环集合
        this.pgpSecretKeyRingCollection = new PGPSecretKeyRingCollection(PGPUtil.getDecoderStream(privateKeyIn)
                , new JcaKeyFingerprintCalculator());
    }

    /**
     * @param privateKeyStr
     * @param passCode
     * @throws IOException
     * @throws PGPException
     */
    public PgpDecryptionUtil(String privateKeyStr, String passCode) throws IOException, PGPException {
        // 将私钥字符串转换为输入流
        this(IOUtils.toInputStream(privateKeyStr, Charset.defaultCharset()), passCode);
    }

    /**
     * 查找指定ID的私钥
     *
     * @param keyID
     * @return
     * @throws PGPException
     */
    private PGPPrivateKey findSecretKey(long keyID) throws PGPException {
        // 从密钥环中获取指定ID的私钥
        PGPSecretKey pgpSecretKey = pgpSecretKeyRingCollection.getSecretKey(keyID);
        // 使用密码解密私钥
        return pgpSecretKey == null ? null : pgpSecretKey.extractPrivateKey(new JcePBESecretKeyDecryptorBuilder()
                .setProvider(BouncyCastleProvider.PROVIDER_NAME).build(passCode));
    }

    /**
     * 解密方法，将加密输入流解密为明文输出流
     *
     * @param encryptedIn
     * @param clearOut
     * @throws PGPException
     * @throws IOException
     */
    public void decrypt(InputStream encryptedIn, OutputStream clearOut)
            throws PGPException, IOException {
        // 去除ASCII Armor并返回底层的二进制加密流
        encryptedIn = PGPUtil.getDecoderStream(encryptedIn);
        JcaPGPObjectFactory pgpObjectFactory = new JcaPGPObjectFactory(encryptedIn);

        Object obj = pgpObjectFactory.nextObject();
        // 第一个对象可能是标记数据包
        PGPEncryptedDataList pgpEncryptedDataList = (obj instanceof PGPEncryptedDataList)
                ? (PGPEncryptedDataList) obj : (PGPEncryptedDataList) pgpObjectFactory.nextObject();

        PGPPrivateKey pgpPrivateKey = null;
        PGPPublicKeyEncryptedData publicKeyEncryptedData = null;

        Iterator<PGPEncryptedData> encryptedDataItr = pgpEncryptedDataList.getEncryptedDataObjects();
        while (pgpPrivateKey == null && encryptedDataItr.hasNext()) {
            publicKeyEncryptedData = (PGPPublicKeyEncryptedData) encryptedDataItr.next();
            pgpPrivateKey = findSecretKey(publicKeyEncryptedData.getKeyID()); // 查找私钥
        }

        if (Objects.isNull(publicKeyEncryptedData)) {
            throw new PGPException("无法生成PGPPublicKeyEncryptedData对象");
        }

        if (pgpPrivateKey == null) {
            throw new PGPException("无法提取私钥");
        }
        CommonUtils.decrypt(clearOut, pgpPrivateKey, publicKeyEncryptedData); // 调用通用解密方法
    }

    /**
     * 解密方法，将加密字节数组解密为明文字节数组
     *
     * @param encryptedBytes
     * @return
     * @throws PGPException
     * @throws IOException
     */
    public byte[] decrypt(byte[] encryptedBytes) throws PGPException, IOException {
        ByteArrayInputStream encryptedIn = new ByteArrayInputStream(encryptedBytes);
        ByteArrayOutputStream clearOut = new ByteArrayOutputStream();
        // 调用解密方法
        decrypt(encryptedIn, clearOut);
        // 将解密后的明文字节数组返回
        return clearOut.toByteArray();
    }
}

CommonUtils

package com.artisan.pgpUtils;

import org.apache.commons.io.IOUtils;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.openpgp.PGPCompressedData;
import org.bouncycastle.openpgp.PGPException;
import org.bouncycastle.openpgp.PGPLiteralData;
import org.bouncycastle.openpgp.PGPLiteralDataGenerator;
import org.bouncycastle.openpgp.PGPOnePassSignatureList;
import org.bouncycastle.openpgp.PGPPrivateKey;
import org.bouncycastle.openpgp.PGPPublicKey;
import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData;
import org.bouncycastle.openpgp.PGPPublicKeyRing;
import org.bouncycastle.openpgp.PGPPublicKeyRingCollection;
import org.bouncycastle.openpgp.PGPUtil;
import org.bouncycastle.openpgp.jcajce.JcaPGPObjectFactory;
import org.bouncycastle.openpgp.operator.PublicKeyDataDecryptorFactory;
import org.bouncycastle.openpgp.operator.jcajce.JcaKeyFingerprintCalculator;
import org.bouncycastle.openpgp.operator.jcajce.JcePublicKeyDataDecryptorFactoryBuilder;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.Date;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Optional;

/**
 * @author artisan
 */
public class CommonUtils {

    /**
     * 使用提供的私钥解密公钥加密数据，并将其写入输出流
     *
     * @param clearOut               要写入数据的输出流
     * @param pgpPrivateKey          私钥实例
     * @param publicKeyEncryptedData 公钥加密数据实例
     * @throws IOException  IO相关错误
     * @throws PGPException PGP相关错误
     */
    static void decrypt(OutputStream clearOut, PGPPrivateKey pgpPrivateKey, PGPPublicKeyEncryptedData publicKeyEncryptedData) throws IOException, PGPException {
        PublicKeyDataDecryptorFactory decryptorFactory = new JcePublicKeyDataDecryptorFactoryBuilder()
                .setProvider(BouncyCastleProvider.PROVIDER_NAME).build(pgpPrivateKey);
        InputStream decryptedCompressedIn = publicKeyEncryptedData.getDataStream(decryptorFactory);

        JcaPGPObjectFactory decCompObjFac = new JcaPGPObjectFactory(decryptedCompressedIn);
        PGPCompressedData pgpCompressedData = (PGPCompressedData) decCompObjFac.nextObject();

        InputStream compressedDataStream = new BufferedInputStream(pgpCompressedData.getDataStream());
        JcaPGPObjectFactory pgpCompObjFac = new JcaPGPObjectFactory(compressedDataStream);

        Object message = pgpCompObjFac.nextObject();

        if (message instanceof PGPLiteralData) {
            PGPLiteralData pgpLiteralData = (PGPLiteralData) message;
            InputStream decDataStream = pgpLiteralData.getInputStream();
            IOUtils.copy(decDataStream, clearOut);
            clearOut.close();
        } else if (message instanceof PGPOnePassSignatureList) {
            throw new PGPException("加密消息包含签名消息而不是文字数据");
        } else {
            throw new PGPException("消息不是简单加密文件 - 类型未知");
        }
        // 执行完整性检查
        if (publicKeyEncryptedData.isIntegrityProtected()) {
            if (!publicKeyEncryptedData.verify()) {
                throw new PGPException("消息未通过完整性检查");
            }
        }
    }

    /**
     * 将输入流中的数据复制到pgp文字数据，并写入提供的输出流
     *
     * @param outputStream 输出流，要写入其中的数据
     * @param in           要读取数据的输入流
     * @param length       要读取的数据长度
     * @param bufferSize   缓冲区大小，因为使用缓冲区加速复制
     * @throws IOException IO相关错误
     */
    static void copyAsLiteralData(OutputStream outputStream, InputStream in, long length, int bufferSize) throws IOException {
        PGPLiteralDataGenerator lData = new PGPLiteralDataGenerator();
        OutputStream pOut = lData.open(outputStream, PGPLiteralData.BINARY, PGPLiteralData.CONSOLE,
                Date.from(LocalDateTime.now().toInstant(ZoneOffset.UTC)), new byte[bufferSize]);
        byte[] buff = new byte[bufferSize];
        try {
            int len;
            long totalBytesWritten = 0L;
            while (totalBytesWritten <= length && (len = in.read(buff)) > 0) {
                pOut.write(buff, 0, len);
                totalBytesWritten += len;
            }
            pOut.close();
        } finally {
            // 清除缓冲区
            Arrays.fill(buff, (byte) 0);
            // 关闭输入流
            in.close();
        }
    }

    /**
     * 从密钥输入流获取公钥
     *
     * @param keyInputStream 密钥输入流
     * @return PGPPublicKey实例
     * @throws IOException  IO相关错误
     * @throws PGPException PGP相关错误
     */
    static PGPPublicKey getPublicKey(InputStream keyInputStream) throws IOException, PGPException {
        PGPPublicKeyRingCollection pgpPublicKeyRings = new PGPPublicKeyRingCollection(
                PGPUtil.getDecoderStream(keyInputStream), new JcaKeyFingerprintCalculator());
        Iterator<PGPPublicKeyRing> keyRingIterator = pgpPublicKeyRings.getKeyRings();
        while (keyRingIterator.hasNext()) {
            PGPPublicKeyRing pgpPublicKeyRing = keyRingIterator.next();
            Optional<PGPPublicKey> pgpPublicKey = extractPGPKeyFromRing(pgpPublicKeyRing);
            if (pgpPublicKey.isPresent()) {
                return pgpPublicKey.get();
            }
        }
        throw new PGPException("无效的公钥");
    }

    private static Optional<PGPPublicKey> extractPGPKeyFromRing(PGPPublicKeyRing pgpPublicKeyRing) {
        for (PGPPublicKey publicKey : pgpPublicKeyRing) {
            if (publicKey.isEncryptionKey()) {
                return Optional.of(publicKey);
            }
        }
        return Optional.empty();
    }

}

PgpEncryptionTest

package com.artisan.pgpUtils;

import org.apache.commons.io.IOUtils;
import org.bouncycastle.bcpg.CompressionAlgorithmTags;
import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
import org.bouncycastle.openpgp.PGPException;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.util.Optional;

import static org.junit.Assert.assertEquals;

public class PgpEncryptionTest {

    public static final TemporaryFolder tempFolder = new TemporaryFolder();

    private PgpEncryptionUtil pgpEncryptionUtil = null;
    private PgpDecryptionUtil pgpDecryptionUtil = null;

    /**
     * 加载资源文件的辅助方法
     * @param resourcePath
     * @return
     */
    private static URL loadResource(String resourcePath) {
        return Optional.ofNullable(PgpEncryptionTest.class.getResource(resourcePath))
                .orElseThrow(() -> new IllegalArgumentException("Resource not found"));
    }

    private static final String passkey = "dummy";
    private final URL privateKey = loadResource("/private.pgp");
    private final URL publicKey = loadResource("/public.pgp");

    private final URL testFile = loadResource("/Sample_CSV_5300kb.csv");

    private static final String testString = "This text needs to be PGP encrypted";

    /**
     * 在测试类运行之前创建临时文件夹
     * @throws IOException
     */
    @BeforeClass
    public static void construct() throws IOException {
        tempFolder.delete();
        tempFolder.create();
    }

    /**
     * 在测试类运行之后清理临时文件夹
     */
    @AfterClass
    public static void destroy() {
        tempFolder.delete();
    }

    /**
     *  初始化方法，在每个测试方法运行之前执行
     */
    @Before
    public void init() {
        // 初始化加密工具类
        pgpEncryptionUtil = PgpEncryptionUtil.builder()
                .armor(true)
                .compressionAlgorithm(CompressionAlgorithmTags.ZIP)
                .symmetricKeyAlgorithm(SymmetricKeyAlgorithmTags.AES_128)
                .withIntegrityCheck(true)
                .build();

        try {
            // 初始化解密工具类
            pgpDecryptionUtil = new PgpDecryptionUtil(privateKey.openStream(), passkey);
        } catch (IOException | PGPException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     *  测试字节数组加密
     * @throws IOException
     * @throws PGPException
     */
    @Test
    public void testByteEncryption() throws IOException, PGPException {
        // 加密测试字节数组
        byte[] encryptedBytes = pgpEncryptionUtil.encrypt(testString.getBytes(Charset.defaultCharset()),
                publicKey.openStream());
        // 解密生成的加密字节数组
        byte[] decryptedBytes = pgpDecryptionUtil.decrypt(encryptedBytes);
        // 将解密后的字节数组转换为字符串，并与原始测试字符串进行比较
        assertEquals(testString, new String(decryptedBytes, Charset.defaultCharset()));
    }

    /**
     * 测试文件加密
     * @throws IOException
     * @throws URISyntaxException
     * @throws PGPException
     */
    @Test
    public void testFileEncryption() throws IOException, URISyntaxException, PGPException {
        // 生成一个从测试文件生成的PGP加密临时文件
        File encryptedFile = tempFolder.newFile();
        File originalFile = new File(testFile.toURI());
        try (OutputStream fos = Files.newOutputStream(encryptedFile.toPath())) {
            pgpEncryptionUtil.encrypt(fos, Files.newInputStream(originalFile.toPath()), originalFile.length(),
                    publicKey.openStream());
        }
        // 解密生成的PGP加密临时文件，并写入另一个临时文件
        File decryptedFile = tempFolder.newFile();
        pgpDecryptionUtil.decrypt(Files.newInputStream(encryptedFile.toPath()), Files.newOutputStream(decryptedFile.toPath()));
        // 比较原始文件内容与解密后的文件内容
        assertEquals(IOUtils.toString(Files.newInputStream(originalFile.toPath()), Charset.defaultCharset()),
                IOUtils.toString(Files.newInputStream(decryptedFile.toPath()), Charset.defaultCharset()));
    }

    /**
     * 测试输入流加密
     * @throws IOException
     * @throws URISyntaxException
     * @throws PGPException
     */
    @Test
    public void testInputStreamEncryption() throws IOException, URISyntaxException, PGPException {
        // 生成一个从测试文件生成的PGP加密输入流
        File originalFile = new File(testFile.toURI());
        InputStream encryptedIn = pgpEncryptionUtil.encrypt(Files.newInputStream(originalFile.toPath()), originalFile.length(), publicKey.openStream());
        // 解密生成的输入流，并写入临时文件
        File decryptedFile = tempFolder.newFile();
        pgpDecryptionUtil.decrypt(encryptedIn, Files.newOutputStream(decryptedFile.toPath()));
        // 比较原始文件内容与解密后的文件内容
        assertEquals(IOUtils.toString(Files.newInputStream(originalFile.toPath()), Charset.defaultCharset()),
                IOUtils.toString(Files.newInputStream(decryptedFile.toPath()), Charset.defaultCharset()));
    }

    /**
     * 使用新配置测试字节数组加密
     * @throws IOException
     * @throws PGPException
     */
    @Test
    public void testByteEncryptionWithNewConf() throws IOException, PGPException {
        pgpEncryptionUtil = PgpEncryptionUtil.builder()
                .armor(false)
                .compressionAlgorithm(CompressionAlgorithmTags.BZIP2)
                .symmetricKeyAlgorithm(SymmetricKeyAlgorithmTags.BLOWFISH)
                .withIntegrityCheck(false)
                .build();
        // 加密测试字节数组
        byte[] encryptedBytes = pgpEncryptionUtil.encrypt(testString.getBytes(Charset.defaultCharset()),
                publicKey.openStream());
        // 解密生成的加密字节数组
        byte[] decryptedBytes = pgpDecryptionUtil.decrypt(encryptedBytes);
        // 将解密后的字节数组转换为字符串，并与原始测试字符串进行比较
        assertEquals(testString, new String(decryptedBytes, Charset.defaultCharset()));
    }
}

在这里插入图片描述

小结

当我们在互联网上发送电子邮件或文件时，我们希望它们的内容能够保密，并且我们希望确认发送方的身份和数据的完整性。这就是PGP（Pretty Good Privacy）的作用。

想象一下，你有一把钥匙。这把钥匙有两个部分：一个是公钥，一个是私钥。

  • 公钥：就像你家门口的邮箱钥匙一样，你可以把它给任何人。任何人都可以用你的公钥锁住一份文件，但只有你才能用你的私钥打开它。

  • 私钥：就像你的家里的钥匙一样，只有你有它。你用它来打开那些别人用你的公钥锁住的文件。

当你想给某人发送私密信息时，你会使用他们的公钥来加密消息。然后，只有他们可以使用自己的私钥来解密消息。这样，即使在传输过程中，即使有人截获了消息，他们也无法阅读它，因为他们没有私钥。

此外，PGP还可以用于数字签名。就像在一封信上签名一样，数字签名证明了发送方的身份和消息的完整性。发送方使用自己的私钥对消息进行签名，然后接收方使用发送方的公钥来验证签名，确保消息没有被篡改，并且是来自于发送方的。

总而言之，PGP是一种用于保护电子邮件和文件安全的加密技术，它通过使用公钥和私钥来加密和解密消息，并通过数字签名来验证消息的来源和完整性。

在这里插入图片描述

PGP加密加密
hubxx的博客
01-07 1200
简介 PGP PGP 是 1990 年左右由 菲利普·齐墨尔曼（Phil Zimmermann）个人编写的密码软件，现在依然在世界上被广泛使用。 PGP 这个名字是 Pretty Good Privacy（很好的隐私）的缩写。 PGP 可以在 Windows、Mac OS X、Linux 等很多平台上运行，版本包括商用版和免费版。此为还有一个由 GNU 遵照 OpenPGP 规范编写的叫做 GnuPG 的自由软件。 OpenPGP OpenPGP 是对密文和数字签名格式进行定义的标准规
【整挺好协议 - OpenPGP 加密协议】
qq_38428433的博客
03-21 966
典型场景：端到端加密 ，发送方使用接收方的公钥进行加密，只有接收方使用自身的私钥才能看到加密内容，中间途径的服务器都无法查看，这样只有发送方和接收方知道数据内容，极大的保障了数据的隐私。其实我们每天都用https - tls 加密，也是这个思路 ，发送端可以是用户使用的浏览器 ，接收端是服务器，浏览器和服务器在连接时 ，，这样尤其在原始数据大的情况下，使用对称加密更合适，保障安全的同时，也可以很大减少加密成本。由上，随机密钥 使用非对称加密 ， 原始数据 使用对称加密，这样是有好处的，因为。
PGP加密通信原理与实战解密
最新发布
weixin_35749786的博客
09-15 1410
本文还有配套的精品资源，点击获取 简介：PGP是一种结合非对称和对称加密技术的电子邮件加密软件，利用RSA算法生成公私钥对进行数据加密和解密，保证通信的安全性。本程序模拟PGP的基础原理，详细讲解了RSA算法的工作机制，以及PGP如何高效地通过公钥和私钥确保数据的隐私和完整性。通过深入分析包含C++代码的"PGP.cpp"文件，学习者将掌握PGP的核心技术，包括素数生成、模...
PGP加密
GoodLuckAC的博客
04-13 1676
PGP加密 含义 PGP加密系统是采用公开密钥加密与传统密钥加密相结合的一种加密技术。它使用一对数学上相关的钥匙，其中一个（公钥）用来加密信息，另一个（私钥）用来解密信息。PGP采用的传统加密技术部分所使用的密钥称为“会话密钥”（sek）。每次使用时，PGP都随机产生一个128位的IDEA会话密钥，用来加密报文。公开密钥加密技术中的公钥和私钥则用来加密会话密钥，并通过它间接地保护报文内容。 PGP（Pretty Good Privacy），是一个基于RSA公匙加密体系的邮件加密软件。可以用它对你.
PGP 协议
mischen520的博客
12-08 1276
再对 P1.Z 采用 IDEA 算法加密，这次加密使用一个一次性的密钥 K，并且 K 必须经过 RSA 算法使用通信的另一方 B 的公开密钥 PKB 加密，与加密后的报文 P2 一起，再经过 BASE64 编码，得到一系列 ASCII 码，作为邮件内容发送到网络上。一般来说，电子邮件在网络上的传输是不加密的。通过组合使用这些加密方法，把 RSA 公钥加密体系的良好加密效果和对称密钥加密体系的高速度结合起来，并且通过在数字签名和密钥认证管理机制中的巧妙设计，使得 PGP 成为一个优秀的强有力的数据加密程序。
关于PGP & GPG文件加密有这篇就够了
留白
04-27 6876
最近要对接亚马逊PSP，需要用到GPG对文件进行加密，记录一下，共勉。另外说一点，GPG是PGP的升级款，支持的加密方式更多，GPG是开源的，而PGP是Symantec公司的版权。所以，我们常说的PGP文件加密，就可以使用GPG方式来搞就可以。就是一套用于加密，解密或者签名的应用程序。而GPG就是 GnuPG 也就是 GNU Privacy Guard。一般用来加密文件：可以生成密钥对、签名/验签、加密/解密等操作。不过文中有几处错误，不知道是版本更新了还是笔误，大部分还是没问题的。
计算机系统安全 实验二 PGP加密软件的安装和使用
m0_58891880的博客
05-16 6916
本次实验先在本地测试加密解密文件，之后和同学合作，使用对方的公钥进行加密，将加密之后的文件发给对方，对方成功使用他的私钥解密文件，验证了非对称加密算法的安全性，及通信双方同时拥有自己的私钥和公钥，A向B发送信息，A先取得B的公钥，使用B的公钥进行加密，B接收到信息，使用自己的私钥进行解密，即在不暴露双方私钥的情况下，完成交付。3. 公钥导入后是关闭状态，我们要将他开启，点击 密钥/签名，在“更多选择”中，勾选最后一个（信任），点击ok，一直OK，直到开启成功。（2）. 确认粉碎文件无误后，点击“是”。
bouncy-gpg:再次将Bouncy Castle与OpenPGP结合使用会很有趣！
05-04
只需几行代码即可加密，解密，签名和验证GPG / PGP文件 通过使用读取加密文件来保护所有 您甚至可以-永远不要让纯文本打入您的服务器磁盘！ 例子 Bouncy GPG内置了几个。 密钥管理 Bouncy GPG支持读取gpg 密钥环和...
PGPro:适用于 iOS 的 OpenPGP 加密和解密应用程序
08-04
PGPro 可以加密和解密消息以及管理您所有的 OpenPGP 密钥。 它是免费、简单和轻量级的。 一切都留在您的设备上。 PGPro 是瑞士制造的。 截图 贡献 欢迎您做出贡献。 请创建一个。 变更日志 请参阅 。 执照 该项目在...
gpg4win-2.0.0.rar_Gpg4win 2.0.0_win gpg
09-19
GPG4win 2.0.0版本在Windows平台上为用户提供了一整套的加密和验证工具，使得在Windows环境下也能享受到与Unix/Linux平台相同的高级安全服务。 该软件的主要组件包括： 1. **GnuPG**：这是Gpg4win的核心，负责执行...
java pgp加密_Java PGP加密解密实例教程详细操作步骤
weixin_29644109的博客
02-13 893
本文将一步步告诉大家PGP的使用步骤，看完大家就立马可以在项目及工作环境中使用起来，so easy!!!1，首先了解什么是PGP，PGP的工作原理是什么？这个直接百度百科，我不啰嗦。PGP是英文Pretty Good Privacy(更好地保护隐私)的简称，百度百科介绍：http://baike.baidu.com/link?url=5cONqc560BbLi0pFPQZ_shK1IrK_Lzkj...
PGP邮件加密
11-22
PGP(pretty good privacy)是一个基于RSA公开密钥加密体系和传统加密体系杂合的邮件加密软件包。可以用它对邮件加密以防止非授权者阅读，它还能对邮件加上数字签名从而使收信人可以确认邮件的发送者，并能确信邮件没有被篡改。它可以提供一种安全的通信方式，而事先并不需要任何保密的渠道用来传递密匙。
PGP加密软件
04-27
加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件加密软件
PGP加密软件(内含注册码)
12-17
PGP 8.1 加密软件(内含注册码)，保证可用
pgp-disk加密
12-31
pgp加密软件，基于RSA公钥加密体系的邮件加密软件。采用了一种RSA和传统加密的杂合算法。可用于文件加密，更加安全。
pgp加密软件
10-10
PGP是目前最优秀，最安全的加密方式。这方面的代表软件是美国的PGP加密软件。这种软件的核心思想是利用逻辑分区保护文件，比如，逻辑分区E:是受PGP保护的硬盘分区，那么，每次打开这个分区的时候，需要输入密码才能打开这个分区，在这个分区内的文件是绝对安全的。不再需要这个分区时，可以把这个分区关闭并使其从桌面上消失，当再次打开时，需要输入密码。没有密码，软件开发者本人也无法解密！PGP是全世界最流行的文件夹加密软件。它的源代码是公开的，经受住了成千上万顶尖黑客的破解挑战，事实证明PGP是目前世界上最安全的加密软件。PGP技术是美国国家安全部门禁止出口的技术。
PGP 加解密及签名验签示例
09-23
它基于公开密钥加密算法，如RSA和IDEA，确保数据在传输过程中的安全性和完整性。在本示例中，我们将深入探讨PGP的核心功能：加解密和签名验证。 1. **PGP 公钥与私钥** - **公钥加密**：PGP系统中，每个人有一对...
pgp加密
zsyqwe的博客
01-14 844
一.由于.net项目中用到了pgp加密协议 主要是生成公钥和私钥 利用公钥加密 私钥解密 DidiSoft.BouncyCastle DidiSoft.Pgp 两个dll 并在项目中引入DidiSoft.Pgp命名空间 类库下载地址 https://didisoft.com/net-openpgp 二 1.首先生成秘钥存储 /// /// 生成存储秘钥 /// /// public static void GenerateKeyStore() { //文件路劲和密码 KeyStore ks = n
PGP加密介绍
协议分析与还原
07-18 4159
点击上方↑↑↑蓝字[协议分析与还原]关注我们“PGP使用避坑指南。”作为一款历史悠久的加密验证工具，PGP在商用领域和个人领域都有广泛的应用，从互联网远古时代开始，积累了一批又一批的粉丝...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小工匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值