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

于 2024-06-25 08:35:05 发布
阅读量723 收藏 15
点赞数 30
文章标签： 安全 java github
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dzqxwzoe/article/details/139945588
版权
文章目录
  • PGP
  • OpenPGP
  • GPG
  • 工作原理
  • 工作流程
  • 用途
  • 案例说明
  • * 过程
  • 代码实现
  • * pom依赖
    • PgpEncryptionUtil
    • PgpDecryptionUtil
    • CommonUtils
    • PgpEncryptionTest
  • 小结

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/b0e521a878fb49a1882c7ea0f8afc933.png)

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）涉及加密、数字签名和密钥管理等关键步骤

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/8bed32d5976c4ad8a33e5e47a4509485.png)

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

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

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

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

工作流程

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

  2. 加密消息 :

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

  3. 解密消息 :

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

  4. 数字签名验证 :

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

  5. 信任管理 :

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

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

用途

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/5d849d6063174772a7438956b2cd05af.png)

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.

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/643c408227c1420396c0ed2c50deb2d5.png)

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()));
    }
}

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/4d1a65a00f2b4178b95258965f6cac7d.png)

小结

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

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

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

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

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

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

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

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/0ec988ed3d6c41ad878d02f9c704391a.jpeg#pic_center)

接下来我将给各位同学划分一张学习计划表！

学习计划

那么问题又来了，作为萌新小白，我应该先学什么，再学什么？
既然你都问的这么直白了，我就告诉你，零基础应该从什么开始学起：

阶段一：初级网络安全工程师

接下来我将给大家安排一个为期1个月的网络安全初级计划，当你学完后，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web渗透、安全服务、安全分析等岗位；其中，如果你等保模块学的好，还可以从事等保工程师。

综合薪资区间6k~15k

1、网络安全理论知识（2天）
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）

2、渗透测试基础（1周）
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等

3、操作系统基础（1周）
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）

4、计算机网络基础（1周）
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现

5、数据库基础操作（2天）
①数据库基础
②SQL语言基础
③数据库安全加固

6、Web渗透（1周）
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）

那么，到此为止，已经耗时1个月左右。你已经成功成为了一名“脚本小子”。那么你还想接着往下探索吗？

阶段二：中级or高级网络安全工程师（看自己能力）

综合薪资区间15k~30k

7、脚本编程学习（4周）
在网络安全领域。是否具备编程能力是“脚本小子”和真正网络安全工程师的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力。

零基础入门的同学，我建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习
搭建开发环境和选择IDE，PHP环境推荐Wamp和XAMPP，IDE强烈推荐Sublime；

Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，没必要看完

用Python编写漏洞的exp,然后写一个简单的网络爬虫

PHP基本语法学习并书写一个简单的博客系统

熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)

了解Bootstrap的布局或者CSS。

阶段三：顶级网络安全工程师

如果你对网络安全入门感兴趣，那么你需要的话可以点击这里👉网络安全重磅福利：入门&进阶全套282G学习资源包免费分享！

学习资料分享

当然，只给予计划不给予学习资料的行为无异于耍流氓，这里给大家整理了一份【282G】的网络安全工程师从入门到精通的学习资料包，可点击下方二维码链接领取哦。

程序员小强_
关注
  • 30
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PGPro:适用于 iOS 的 OpenPGP 加密和解密应用程序
08-04
PGPro 可以加密和解密消息以及管理您所有的 OpenPGP 密钥。 它是免费、简单和轻量级的。 一切都留在您的设备上。 PGPro 是瑞士制造的。 截图 贡献 欢迎您做出贡献。 请创建一个。 变更日志 请参阅 。 执照 该项目在...
Crypt_GPG:使用PHP加密PGP消息
05-04
Crypt_GPG提供了一个面向对象的API，用于使用GnuPG执行OpenPGP操作。 已从迁移。文献资料快速范例<?phprequire_once 'Crypt/GPG.php' ;$ gpg = new Crypt_GPG ();$ gpg -> addEncryptKey ( 'test@example.com' )...
15、PGP协议
安全学习笔记
07-23 1万+
PGP协议 1)PGP (Pretty Good Privacy)，一个提供加密和认证的基于 RSA 公钥及 AES 等加密算法的加密软件系列。PGP经常被用于签名、加密和解密电子邮件，以增加电子邮件通信的安全性，可以用它对邮件保密以防止非授权者阅读，它还能对邮件加上数字签名从而使收信人可以确认邮件的发送者，并能确信邮件没有被篡改。它可以提供一种安全的通讯方式，而事先并不需要任何保密的渠道用来传递密匙。它采用了一种 RSA 和传统加密的杂合算法，用于数字签名的邮件文摘算法，加密前压缩等，还有一个良好的人机
PGP加密介绍
协议分析与还原
07-18 3972
点击上方↑↑↑蓝字[协议分析与还原]关注我们“PGP使用避坑指南。”作为一款历史悠久的加密验证工具，PGP在商用领域和个人领域都有广泛的应用，从互联网远古时代开始，积累了一批又一批的粉丝...
【软考网络管理员】2023年软考网管初级常见知识考点（18）-安全协议SSL与PGP、数据加密技术
赏樱看雪撸代码
06-26 1740
安全套接层协议SSL详解，PGP协议是什么？数据加密技术有哪些？软考网络管理员常考知识点，软考网络管理员网络安全，网络管理员考点汇总。
PGP的安装及使用，利用加密软件PGP对邮件内容进行加密和解密，保姆级教学
热门推荐
qq_29350567的博客
11-08 2万+
利用加密软件PGP对邮件进行加密和认证，保姆级教学安装加密软件新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 安装加密软件 安装基本上都是傻瓜教程，但是为了大家做的放心，我还是会将详细的安装教程写下来 新的改变 我们对Ma
opengpg
maybe的博客
05-27 311
gpg是一个用来加解密的工具，可以用来验证文件是否被破坏。 常用命令有： gpg --gen-key gpg --gen-revoke gpg --import gpg --edit-key $KEY trust gpg --recipient gpg --decrypt gpg --sign gpg --verify
OpenPGP：Webapp使用FirefoxOS的PGP进行加密/解密
02-06
OpenPGP WebApp将GPG消息加密端口移植到FirefoxOS。 有可能： 生成密钥对 从加载公钥 从SD卡中的文件加载私钥 加密消息并通过电子邮件发送 解密消息 管理本地保存的密钥 历史 1.0 第一版 1.5 在生成新密码对时增加...
bouncy-gpg:再次将Bouncy Castle与OpenPGP结合使用会很有趣！
05-04
只需几行代码即可加密，解密，签名和验证GPG / PGP文件 通过使用读取加密文件来保护所有 您甚至可以-永远不要让纯文本打入您的服务器磁盘！ 例子 Bouncy GPG内置了几个。 密钥管理 Bouncy GPG支持读取gpg 密钥环和...
gpg4win-2.0.0.rar_Gpg4win 2.0.0_win gpg
09-19
GPG4win 2.0.0版本在Windows平台上为用户提供了一整套的加密和验证工具，使得在Windows环境下也能享受到与Unix/Linux平台相同的高级安全服务。 该软件的主要组件包括： 1. **GnuPG**：这是Gpg4win的核心，负责执行...
gopenpgp:一个高级 OpenPGP 库
07-24
GopenPGP V2 GopenPGP 是一个高级 OpenPGP 库，构建在的。 目录 下载/安装 供应商安装 要使用Go Modules使用此库，只需编辑您的go.mod配置以包含： require ( ... github.com/ProtonMail/gopenpgp/v2 v2.0.1 ) 然后可以通过运行安装它： go mod vendor 最后，您的软件可以将其包含在您的软件中，如下所示： package main import ( "fmt" "github.com/ProtonMail/gopenpgp/v2/crypto" ) func main () { fmt . Println ( crypto . GetUnixTime ()) } Git-Clone 安装 要安装开发模式，克隆存储库，可以通过以下方式完成： c
PGP 加解密及签名验签示例
09-23
它基于公开密钥加密算法，如RSA和IDEA，确保数据在传输过程中的安全性和完整性。在本示例中，我们将深入探讨PGP的核心功能：加解密和签名验证。 1. **PGP 公钥与私钥** - **公钥加密**：PGP系统中，每个人有一对...
gpg加密解密 加密工具.zip
05-18
GPG，全称为GNU Privacy Guard，是GNU项目的一部分，它是一个免费且开源的加密软件，用于实现OpenPGP标准（RFC 4880），提供数据加密和数字签名功能。在IT领域，GPG是安全通信和数据保护的重要工具，尤其对于保护...
johnnycanencrypt:用Rust编写的OpenPGP的Python模块
05-24
约翰尼可以加密 Johnnycanencrypt aka jce是用Rust编写的Python模块，用于执行基本的加密和解密操作。 它为实际的OpenPGP操作使用了惊人的库。 注意-在当前状态下，这是非常实验性的代码，请不要在生产中使用它。...
encrypt.to:一键发送加密的PGP消息
05-02
加密为通过发送加密的PGP消息它是如何工作的？ 将您的公共密钥添加到公共密钥服务器后，打开链接： ...
网络安全PGP加解密签名实验
最新发布
在校大学生
12-20 1190
第八步 先签名（用自己的私钥）再加密（用合作方的公钥）文件，选第四个。第六步 数字签名（使用自己的私钥签名，合作方使用自己的公钥认证）选中对方发过来的加密文件，输入口令解密即可。第七步：对邮件进行数字签名。
PGP数据加密
chileique7275的博客
07-16 468
PGP (Pretty Good Privacy)是由 Phil Zimmermann 于 1991 开发的一个用于数据加密和数字签名的程序，由于被广泛应用以至于后来形成一个开放的标准OpenPGP，而GnuPG则是实现了该标准的一个开源免费程序，本文将会简单介绍如何使用 GnuPG ...
【网络安全技术】电子邮件安全PGP，SMIME
TheSysy的博客
12-13 873
PGP加密解密，公钥管理，Radix-64 algorithm，SMIME
PGP加密是什么？
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
05-06 264
PGP（Pretty Good Privacy，优良保密协议）是一套用于讯息加密、验证的应用程序。PGP 的主要开发者是菲尔·齐默曼。齐默曼于 1991 年将 PGP 在互联网上免费发布。PGP 本身是商业应用程序；开源并具有同类功能的工具名为 GnuPG（GPG）。PGP 及其同类产品均遵守 OpenPGP 数据加解密标准。
如何用python实现openpgp进行邮件的加密与解密
06-07
在Python中实现OpenPGP进行邮件加密和解密，可以使用GnuPG（Gnu Privacy Guard）库，它是一个开源的OpenPGP实现。 以下是一个使用GnuPG进行邮件加密和解密的示例代码： 1. 加密邮件 ```python import gnupg # ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值