【C++实战(74)】深入C++安全编程：密码学实战之旅

一、密码学的基础概念
- [1.1 对称加密与非对称加密的区别（AES、RSA）](#1.1 对称加密与非对称加密的区别（AES、RSA）)
- [1.2 哈希算法的作用（MD5、SHA-256，数据完整性校验）](#1.2 哈希算法的作用（MD5、SHA-256，数据完整性校验）)
- [1.3 数字签名的原理（防止数据篡改、身份验证）](#1.3 数字签名的原理（防止数据篡改、身份验证）)
[二、OpenSSL 库的实战应用](#二、OpenSSL 库的实战应用)
- [2.1 OpenSSL 的基础概念（开源密码学库、支持多种加密算法）](#2.1 OpenSSL 的基础概念（开源密码学库、支持多种加密算法）)
- [2.2 OpenSSL 环境搭建与库链接（Windows/Linux）](#2.2 OpenSSL 环境搭建与库链接（Windows/Linux）)
- [2.3 对称加密（AES-256-CBC）的实现（密钥生成、加密、解密）](#2.3 对称加密（AES-256-CBC）的实现（密钥生成、加密、解密）)
三、哈希与数字签名实战
- [3.1 哈希算法（SHA-256）的使用（计算文件哈希、数据校验）](#3.1 哈希算法（SHA-256）的使用（计算文件哈希、数据校验）)
- [3.2 非对称加密（RSA）的实现（密钥对生成、加密、解密）](#3.2 非对称加密（RSA）的实现（密钥对生成、加密、解密）)
- [3.3 数字签名与验证（基于 RSA+SHA-256）](#3.3 数字签名与验证（基于 RSA+SHA-256）)
四、实战项目：文件加密工具
- [4.1 项目需求（支持 AES 加密文件、RSA 加密 AES 密钥、文件哈希校验）](#4.1 项目需求（支持 AES 加密文件、RSA 加密 AES 密钥、文件哈希校验）)
- [4.2 OpenSSL 实现加密 / 解密与哈希校验代码](#4.2 OpenSSL 实现加密 / 解密与哈希校验代码)
- [4.3 加密安全性测试与密钥管理](#4.3 加密安全性测试与密钥管理)

一、密码学的基础概念

1.1 对称加密与非对称加密的区别（AES、RSA）

在当今数字化时代，信息安全至关重要，密码学作为保障信息安全的关键技术，发挥着不可或缺的作用。对称加密和非对称加密是密码学中两种重要的加密方式，它们在工作方式、特点以及实际应用中都存在着显著的区别。

对称加密，正如其名，加密和解密使用相同的密钥。这就好比你和你的朋友约定了一个秘密的 "通关密语"，当你要传递消息给他时，你用这个 "通关密语" 将消息加密，他收到后，再用同样的 "通关密语" 解密，从而读取消息内容。AES（Advanced Encryption Standard）就是一种典型的对称加密算法，它被广泛应用于各种需要加密大量数据的场景，像金融交易数据的加密存储、通信过程中数据的加密传输等。AES 具有高效快速的特点，能够在短时间内对大量数据进行加密和解密操作，这使得它非常适合处理那些对性能要求较高的场景。然而，对称加密也存在一个明显的问题，那就是密钥的管理。因为发送方和接收方都需要使用相同的密钥，所以在密钥的传递过程中，一旦密钥被窃取，那么整个通信的安全性就会受到严重威胁。就好像你们约定的 "通关密语" 被别人偷听到了，那么别人就可以轻松地破解你们之间传递的消息。

非对称加密则采用了一对密钥，即公钥和私钥。公钥就像是你家的门牌号，你可以公开地告诉任何人；而私钥则像是你家的钥匙，只有你自己拥有并且需要妥善保管。当别人要给你发送加密消息时，他们使用你的公钥对消息进行加密，加密后的消息只有你用自己的私钥才能解密。RSA（Rivest-Shamir-Adleman）算法是最常见的非对称加密算法之一，它在数字签名、身份验证等领域有着广泛的应用。比如，在软件发布时，软件开发者会使用自己的私钥对软件进行签名，用户在下载软件后，可以使用开发者的公钥来验证软件的完整性和来源，确保软件没有被篡改。非对称加密的最大优势在于安全性高，即使公钥被公开，也不用担心私钥被泄露，因为从公钥很难推导出私钥。但是，非对称加密的计算量较大，加密和解密的速度相对较慢，这就使得它不太适合加密大量的数据。

在实际应用中，AES 常用于对大量数据进行加密，如本地文件加密、数据库中敏感数据的加密等。而 RSA 则主要用于密钥交换、数字签名和身份认证等场景，比如在 HTTPS 协议中，就使用了 RSA 来进行服务器和客户端之间的密钥交换，确保通信的安全。总之，对称加密和非对称加密各有优劣，在实际应用中，我们常常会根据具体的需求来选择合适的加密方式，有时甚至会将两者结合使用，以达到更好的安全效果。

1.2 哈希算法的作用（MD5、SHA-256，数据完整性校验）

哈希算法，也被称为散列算法，在密码学和信息安全领域扮演着极为重要的角色。它就像是一个神奇的 "指纹生成器"，能够将任意长度的输入数据，通过特定的数学运算，转换为固定长度的输出值，这个输出值我们称之为哈希值或消息摘要。哈希算法具有几个关键特性，这些特性使得它在数据完整性校验等方面发挥着不可替代的作用。

首先是确定性，相同的输入数据，无论在何时何地进行计算，得到的哈希值都是完全相同的。这就好比无论你在什么时间、什么地点，用同一台复印机复印同一页文件，得到的复印件都是一模一样的。其次是不可逆性，从哈希值几乎不可能反推出原始数据。这为数据的安全性提供了保障，即使哈希值被泄露，攻击者也无法通过它获取原始数据。另外，哈希算法还具有抗碰撞性，也就是说，很难找到两个不同的输入数据，使得它们产生相同的哈希值。这就确保了每个数据都有其独一无二的 "指纹"。

MD5（Message-Digest Algorithm 5）和 SHA-256（Secure Hash Algorithm 256-bit）是两种常见的哈希算法。MD5 曾经被广泛应用，它能够生成 128 位的哈希值，计算速度相对较快。然而，随着技术的发展，MD5 被发现存在一些安全隐患，容易出现碰撞攻击，即不同的输入数据可能产生相同的哈希值，这使得它在安全性要求较高的场景中逐渐被弃用。SHA-256 则是一种更为安全可靠的哈希算法，它生成的哈希值长度为 256 位，具有更强的抗碰撞性。在当前的信息安全领域，SHA-256 被广泛应用于各种需要高度数据完整性保障的场景。

在数据完整性校验方面，哈希算法发挥着核心作用。当我们需要确保数据在传输或存储过程中没有被篡改时，就可以利用哈希算法。例如，在下载软件时，软件的发布者会事先计算软件的哈希值，并将其公布在官方网站上。用户在下载完成后，使用相同的哈希算法计算下载文件的哈希值，然后将自己计算得到的哈希值与官方公布的哈希值进行比对。如果两个哈希值完全一致，那么就可以认为文件在下载过程中没有被篡改，是完整可靠的；反之，如果哈希值不一致，那就说明文件可能已经被恶意篡改，存在安全风险。在文件存储和备份场景中，也可以通过计算文件的哈希值来定期检查文件的完整性，及时发现文件是否被意外修改或损坏。哈希算法就像是数据的 "忠诚卫士"，时刻守护着数据的完整性和安全性。

1.3 数字签名的原理（防止数据篡改、身份验证）

数字签名作为密码学中的一项重要技术，在确保数据完整性和实现身份验证方面发挥着关键作用，其原理基于公钥密码学和哈希函数。

在公钥密码学体系中，每个用户都拥有一对密钥，即公钥和私钥。公钥可以公开传播，而私钥则由用户自己妥善保管，绝不泄露。哈希函数则能够将任意长度的数据转换为固定长度的哈希值，这个哈希值就如同数据的 "数字指纹"，具有唯一性和确定性，哪怕原始数据只发生了微小的变化，其对应的哈希值也会截然不同。

数字签名的具体过程如下：首先，发送方使用哈希函数对要发送的数据进行计算，生成一个哈希值。这个哈希值就代表了原始数据的特征。然后，发送方用自己的私钥对生成的哈希值进行加密，得到数字签名。由于私钥只有发送方拥有，所以这个签名就具有了唯一性，能够证明数据是由发送方产生的。接下来，发送方将原始数据和数字签名一起发送给接收方。接收方收到数据后，会先用发送方的公钥对数字签名进行解密，得到发送方加密前的哈希值。同时，接收方也会使用相同的哈希函数对接收到的原始数据进行计算，生成一个新的哈希值。最后，接收方将解密得到的哈希值和自己计算得到的哈希值进行比对。如果两个哈希值完全一致，那就说明数据在传输过程中没有被篡改，并且确实是由声称的发送方发送的，因为只有拥有对应私钥的发送方才能生成有效的数字签名；反之，如果两个哈希值不一致，那就说明数据可能已经被篡改，或者数据不是由声称的发送方发送的，此时接收方就需要谨慎处理这些数据，以避免遭受安全风险。

数字签名在许多领域都有广泛的应用。在电子合同签署中，通过数字签名可以确保合同内容不被篡改，并且能够明确签署方的身份，使得电子合同具有与传统纸质合同同等的法律效力。在软件发布过程中，软件开发者使用数字签名对软件进行签名，用户在下载软件后可以验证签名，从而确认软件的来源和完整性，防止下载到被恶意篡改的软件。在电子邮件通信中，数字签名也可以用来验证邮件的发件人身份，确保邮件内容没有被中途修改，保障邮件通信的安全。数字签名为数字世界中的数据传输和交互提供了可靠的安全保障，是维护信息安全的重要基石之一。

二、OpenSSL 库的实战应用

2.1 OpenSSL 的基础概念（开源密码学库、支持多种加密算法）

OpenSSL 作为一款具有深远影响力的开源密码学库，在网络安全领域扮演着举足轻重的角色，为众多应用提供了坚实的安全保障。它的出现，极大地推动了加密技术在各个领域的广泛应用，使得开发者能够便捷地为自己的应用添加安全功能。

从本质上讲，OpenSSL 是安全套接字层（SSL）和传输层安全（TLS）协议的开源实现，这两个协议是保障网络通信安全的关键。在当今的互联网环境中，大量的数据在网络中传输，如用户的登录信息、银行交易数据、个人隐私资料等。如果这些数据在传输过程中没有得到有效的保护，就极易被窃取或篡改，从而给用户带来巨大的损失。SSL 和 TLS 协议通过使用对称和非对称加密技术，确保数据在传输过程中的机密性和完整性。例如，当你在网上购物时，你的浏览器与电商服务器之间建立的 HTTPS 连接，其底层就是基于 SSL/TLS 协议实现的，而 OpenSSL 则为这个连接提供了重要的技术支持，使得你的购物信息能够安全地在网络中传输，避免被黑客窃取。

OpenSSL 支持的加密算法丰富多样，涵盖了对称加密、非对称加密和哈希算法等多个类别。在对称加密方面，AES 是其中的佼佼者，它具有高效快速的特点，能够在短时间内对大量数据进行加密和解密操作，因此被广泛应用于各种需要加密大量数据的场景，如文件加密、数据库中敏感数据的加密等。非对称加密算法中的 RSA，以其独特的公钥和私钥机制，在数字签名、身份验证等领域发挥着关键作用。例如，在软件发布时，软件开发者会使用自己的私钥对软件进行签名，用户在下载软件后，可以使用开发者的公钥来验证软件的完整性和来源，确保软件没有被篡改。哈希算法中的 SHA 系列，如 SHA-256，能够将任意长度的数据转换为固定长度的哈希值，这个哈希值就如同数据的 "指纹"，具有唯一性和确定性，哪怕原始数据只发生了微小的变化，其对应的哈希值也会截然不同。因此，SHA-256 常被用于数据完整性校验，比如在文件传输过程中，接收方可以通过计算接收到文件的哈希值，并与发送方提供的哈希值进行比对，来判断文件是否在传输过程中被篡改。

OpenSSL 的应用场景极为广泛，几乎涵盖了互联网的各个角落。在 Web 服务器中，它为网站提供加密连接，使得用户在访问网站时，数据能够安全地传输，防止被第三方窃取或篡改。许多银行网站、电商平台都依赖 OpenSSL 来保障用户的交易安全。在电子邮件客户端中，OpenSSL 可以对邮件内容进行加密，确保邮件在传输和存储过程中的保密性，防止邮件内容被他人窥探。在虚拟专用网络（VPN）中，OpenSSL 同样发挥着重要作用，它帮助建立安全的隧道，使得用户能够在公共网络上安全地传输私有数据，就像在一个专用的网络中一样。OpenSSL 以其强大的功能和广泛的适用性，成为了网络安全领域不可或缺的重要工具。

2.2 OpenSSL 环境搭建与库链接（Windows/Linux）

在 Windows 系统下搭建 OpenSSL 环境，首先需要获取 OpenSSL 的安装包。可以从 OpenSSL 官方网站或者一些可靠的软件下载站点获取，比如 Shining Light Productions 提供的 Win32/Win64 OpenSSL Installer for Windows，这里有 Win32 和 Win64 版本可供选择，用户需根据自己要开发的程序是 32 位还是 64 位来选择对应版本，注意不要下载 light 版本，因为该版本不带 lib 和 include 文件，需要自行编译。下载完成后，运行安装程序，在安装过程中，可根据提示选择安装路径，例如可以安装到C:\OpenSSL目录下。安装完成后，需要将 OpenSSL 的 bin 目录（如C:\OpenSSL\bin）添加到系统的环境变量 PATH 中，这样在命令行中就可以直接使用 OpenSSL 命令。同时，为了在开发中使用 OpenSSL 库，还需要在开发工具（如 Visual Studio）中进行相关配置。以 Visual Studio 为例，打开项目属性，选择 VC++ 目录，在包含目录中添加 OpenSSL 的 include 目录路径，在库目录中添加 OpenSSL 的 lib 目录路径。然后在连接器的输入选项中，将libssl.lib与libcrypto.lib文件添加到附加依赖项中，这样就完成了 Windows 系统下 OpenSSL 环境的搭建与库链接。

在 Linux 系统下搭建 OpenSSL 环境，对于大多数常见的 Linux 发行版，如 Debian/Ubuntu、CentOS/RHEL、Fedora 等，可以使用包管理器进行安装。在 Debian/Ubuntu 系统中，打开终端，执行命令sudo apt-get update更新软件源，然后执行sudo apt-get install openssl即可完成安装；在 CentOS/RHEL 系统中，执行sudo yum install openssl；在 Fedora 系统中，执行sudo dnf install openssl。如果需要特定版本或者对系统有特殊要求，也可以选择从源码编译安装。首先从 OpenSSL 官方网站下载源码压缩包，例如openssl-版本号.tar.gz，下载完成后，使用命令tar -zxvf openssl-版本号.tar.gz解压压缩包，然后进入解压后的目录，执行./config --prefix=/usr/local/openssl进行配置，这里的--prefix参数指定了 OpenSSL 的安装路径，用户可根据自己的需求进行修改。配置完成后，执行make进行编译，编译完成后，再执行sudo make install完成安装。编译安装后，为了确保命令行工具可以被正确调用，还需要配置环境变量。打开终端，编辑用户的 bash 配置文件，如~/.bashrc，在文件中添加export PATH=$PATH:/usr/local/openssl/bin，然后执行source ~/.bashrc使环境变量生效。这样就完成了 Linux 系统下 OpenSSL 环境的搭建。在使用时，若要在 C++ 程序中链接 OpenSSL 库，在编译时使用g++ -o 目标文件名源文件名.cpp -lssl -lcrypto命令即可，其中-lssl和-lcrypto分别表示链接 OpenSSL 的 SSL 库和 Crypto 库。

2.3 对称加密（AES-256-CBC）的实现（密钥生成、加密、解密）

在 C++ 中使用 OpenSSL 库实现 AES-256-CBC 模式的对称加密，首先需要包含相关的头文件，如<openssl/evp.h>和<openssl/err.h>。以下是实现密钥生成、加密和解密的代码示例：

cpp 复制代码

#include <iostream>
#include <openssl/evp.h>
#include <openssl/err.h>
#include <cstring>
#include <cstdlib>

// 错误处理函数
void handleErrors() {
    ERR_print_errors_fp(stderr);
    abort();
}

// 生成随机密钥和IV（初始化向量）
void generateKeyAndIV(unsigned char *key, unsigned char *iv) {
    if (!RAND_bytes(key, 32) ||!RAND_bytes(iv, 16)) {
        handleErrors();
    }
}

// AES-256-CBC加密
int encrypt(const unsigned char *plaintext, int plaintext_len, const unsigned char *key, const unsigned char *iv, unsigned char **ciphertext) {
    EVP_CIPHER_CTX *ctx;
    int len;
    int ciphertext_len;

    // 创建并初始化加密上下文
    if (!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
    if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) handleErrors();

    // 分配密文缓冲区
    *ciphertext = (unsigned char *)malloc(plaintext_len + EVP_CIPHER_CTX_block_size(ctx));
    if (!*ciphertext) handleErrors();

    // 执行加密
    if (1 != EVP_EncryptUpdate(ctx, *ciphertext, &len, plaintext, plaintext_len)) handleErrors();
    ciphertext_len = len;

    // 完成加密
    if (1 != EVP_EncryptFinal_ex(ctx, *ciphertext + len, &len)) handleErrors();
    ciphertext_len += len;

    // 释放加密上下文
    EVP_CIPHER_CTX_free(ctx);

    return ciphertext_len;
}

// AES-256-CBC解密
int decrypt(const unsigned char *ciphertext, int ciphertext_len, const unsigned char *key, const unsigned char *iv, unsigned char **plaintext) {
    EVP_CIPHER_CTX *ctx;
    int len;
    int plaintext_len;

    // 创建并初始化解密上下文
    if (!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
    if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) handleErrors();

    // 分配明文缓冲区
    *plaintext = (unsigned char *)malloc(ciphertext_len);
    if (!*plaintext) handleErrors();

    // 执行解密
    if (1 != EVP_DecryptUpdate(ctx, *plaintext, &len, ciphertext, ciphertext_len)) handleErrors();
    plaintext_len = len;

    // 完成解密
    if (1 != EVP_DecryptFinal_ex(ctx, *plaintext + len, &len)) handleErrors();
    plaintext_len += len;

    // 释放解密上下文
    EVP_CIPHER_CTX_free(ctx);

    return plaintext_len;
}

你可以使用以下方式调用上述函数：

cpp 复制代码

int main() {
    // 初始化OpenSSL
    OpenSSL_add_all_algorithms();
    ERR_load_crypto_strings();

    unsigned char key[32];
    unsigned char iv[16];
    generateKeyAndIV(key, iv);

    const char *plaintext = "Hello, OpenSSL AES-256-CBC!";
    int plaintext_len = strlen(plaintext);

    unsigned char *ciphertext;
    int ciphertext_len = encrypt((const unsigned char *)plaintext, plaintext_len, key, iv, &ciphertext);

    std::cout << "Ciphertext: ";
    for (int i = 0; i < ciphertext_len; ++i) {
        printf("%02x", ciphertext[i]);
    }
    std::cout << std::endl;

    unsigned char *decrypted_text;
    int decrypted_len = decrypt(ciphertext, ciphertext_len, key, iv, &decrypted_text);

    std::cout << "Decrypted text: " << (char *)decrypted_text << std::endl;

    // 释放内存
    free(ciphertext);
    free(decrypted_text);

    // 清理OpenSSL
    EVP_cleanup();
    ERR_free_strings();

    return 0;
}

在上述代码中，generateKeyAndIV函数用于生成随机的密钥和 IV，这是保证加密安全性的重要步骤。encrypt函数实现了 AES-256-CBC 模式的加密操作，它首先创建并初始化加密上下文，然后分配密文缓冲区，接着执行加密操作，最后完成加密并释放加密上下文。decrypt函数则实现了对应的解密操作，其流程与加密类似，先创建并初始化解密上下文，分配明文缓冲区，执行解密操作，完成解密后释放解密上下文。在main函数中，首先初始化 OpenSSL，然后调用generateKeyAndIV生成密钥和 IV，接着对一段明文进行加密，输出加密后的密文，再对密文进行解密，输出解密后的明文，最后释放内存并清理 OpenSSL 环境。通过这些步骤，就实现了 AES-256-CBC 模式的对称加密与解密功能。

三、哈希与数字签名实战

3.1 哈希算法（SHA-256）的使用（计算文件哈希、数据校验）

通过 OpenSSL 库使用 SHA-256 算法计算文件哈希，并用于数据校验，首先需要包含<openssl/sha.h>头文件。下面是一个计算文件哈希值的代码示例：

cpp 复制代码

#include <iostream>
#include <fstream>
#include <openssl/sha.h>
#include <iomanip>
#include <sstream>

std::string calculateFileHash(const std::string& filePath) {
    std::ifstream file(filePath, std::ios::binary);
    if (!file) {
        throw std::runtime_error("无法打开文件: " + filePath);
    }

    file.seekg(0, std::ios::end);
    std::streampos fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    std::vector<char> buffer(fileSize);
    file.read(buffer.data(), fileSize);

    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, buffer.data(), buffer.size());
    SHA256_Final(hash, &sha256);

    std::ostringstream oss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        oss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(hash[i]);
    }

    return oss.str();
}

你可以使用以下方式调用上述函数：

cpp 复制代码

int main() {
    std::string filePath = "test.txt";
    try {
        std::string hash = calculateFileHash(filePath);
        std::cout << "文件 " << filePath << " 的SHA-256哈希值是: " << hash << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }

    return 0;
}

在上述代码中，calculateFileHash函数首先打开指定路径的文件，并读取文件的全部内容到缓冲区。然后，使用 OpenSSL 库中的SHA256_Init函数初始化 SHA-256 计算上下文，SHA256_Update函数将文件内容输入到计算过程中，最后SHA256_Final函数完成计算并得到哈希值。将哈希值转换为十六进制字符串形式返回，方便查看和比较。在main函数中，指定要计算哈希值的文件路径，调用calculateFileHash函数计算哈希值并输出。这样就实现了使用 SHA-256 算法计算文件哈希值的功能，可用于数据完整性校验，比如在文件传输前后计算哈希值，对比哈希值是否一致，以判断文件是否被篡改。

3.2 非对称加密（RSA）的实现（密钥对生成、加密、解密）

使用 OpenSSL 库实现 RSA 非对称加密，需要包含<openssl/rsa.h>、<openssl/pem.h>、<openssl/err.h>等头文件。以下是生成 RSA 密钥对，以及使用密钥对进行加密和解密的代码示例：

cpp 复制代码

#include <iostream>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <cstring>
#include <fstream>
#include <vector>

// 错误处理函数
void handleErrors() {
    ERR_print_errors_fp(stderr);
    abort();
}

// 生成RSA密钥对
void generateRSAKeyPair(const std::string& publicKeyFile, const std::string& privateKeyFile) {
    RSA* rsa = RSA_generate_key(2048, RSA_F4, nullptr, nullptr);
    if (!rsa) {
        handleErrors();
    }

    // 保存私钥到文件
    std::ofstream privateKeyStream(privateKeyFile, std::ios::binary);
    if (!PEM_write_RSAPrivateKey(privateKeyStream, rsa, nullptr, nullptr, 0, nullptr, nullptr)) {
        handleErrors();
    }
    privateKeyStream.close();

    // 保存公钥到文件
    std::ofstream publicKeyStream(publicKeyFile, std::ios::binary);
    if (!PEM_write_RSAPublicKey(publicKeyStream, rsa)) {
        handleErrors();
    }
    publicKeyStream.close();

    RSA_free(rsa);
}

// 使用公钥加密
std::vector<unsigned char> encryptWithPublicKey(const std::string& plaintext, const std::string& publicKeyFile) {
    std::ifstream publicKeyStream(publicKeyFile, std::ios::binary);
    if (!publicKeyStream) {
        throw std::runtime_error("无法打开公钥文件: " + publicKeyFile);
    }
    RSA* rsa = PEM_read_RSAPublicKey(publicKeyStream, nullptr, nullptr, nullptr);
    if (!rsa) {
        handleErrors();
    }

    int flen = plaintext.size();
    std::vector<unsigned char> ciphertext(RSA_size(rsa));
    int clen = RSA_public_encrypt(flen, reinterpret_cast<const unsigned char*>(plaintext.c_str()), ciphertext.data(), rsa, RSA_PKCS1_PADDING);
    if (clen == -1) {
        handleErrors();
    }

    RSA_free(rsa);
    ciphertext.resize(clen);
    return ciphertext;
}

// 使用私钥解密
std::string decryptWithPrivateKey(const std::vector<unsigned char>& ciphertext, const std::string& privateKeyFile) {
    std::ifstream privateKeyStream(privateKeyFile, std::ios::binary);
    if (!privateKeyStream) {
        throw std::runtime_error("无法打开私钥文件: " + privateKeyFile);
    }
    RSA* rsa = PEM_read_RSAPrivateKey(privateKeyStream, nullptr, nullptr, nullptr);
    if (!rsa) {
        handleErrors();
    }

    int clen = ciphertext.size();
    std::vector<unsigned char> plaintext(RSA_size(rsa));
    int flen = RSA_private_decrypt(clen, ciphertext.data(), plaintext.data(), rsa, RSA_PKCS1_PADDING);
    if (flen == -1) {
        handleErrors();
    }

    RSA_free(rsa);
    plaintext.resize(flen);
    return std::string(plaintext.begin(), plaintext.end());
}

你可以使用以下方式调用上述函数：

cpp 复制代码

int main() {
    // 初始化OpenSSL
    OpenSSL_add_all_algorithms();
    ERR_load_crypto_strings();

    std::string publicKeyFile = "public_key.pem";
    std::string privateKeyFile = "private_key.pem";
    generateRSAKeyPair(publicKeyFile, privateKeyFile);

    std::string plaintext = "Hello, RSA!";
    std::vector<unsigned char> ciphertext = encryptWithPublicKey(plaintext, publicKeyFile);

    std::cout << "密文: ";
    for (unsigned char c : ciphertext) {
        printf("%02x", c);
    }
    std::cout << std::endl;

    std::string decryptedText = decryptWithPrivateKey(ciphertext, privateKeyFile);
    std::cout << "解密后的明文: " << decryptedText << std::endl;

    // 清理OpenSSL
    EVP_cleanup();
    ERR_free_strings();

    return 0;
}

在上述代码中，generateRSAKeyPair函数用于生成 2048 位的 RSA 密钥对，并将公钥和私钥分别保存到指定的文件中。encryptWithPublicKey函数从公钥文件中读取公钥，使用公钥对传入的明文进行加密，返回加密后的密文。decryptWithPrivateKey函数从私钥文件中读取私钥，使用私钥对传入的密文进行解密，返回解密后的明文。在main函数中，首先初始化 OpenSSL，然后生成密钥对，接着对一段明文进行加密，输出加密后的密文，再对密文进行解密，输出解密后的明文，最后清理 OpenSSL 环境。通过这些步骤，实现了 RSA 非对称加密的密钥对生成、加密和解密功能。

3.3 数字签名与验证（基于 RSA+SHA-256）

基于 RSA 和 SHA-256 算法进行数字签名的生成与验证，同样需要包含相关的 OpenSSL 头文件。以下是具体的代码实现：

cpp 复制代码

#include <iostream>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <openssl/sha.h>
#include <cstring>
#include <fstream>
#include <vector>

// 错误处理函数
void handleErrors() {
    ERR_print_errors_fp(stderr);
    abort();
}

// 生成数字签名
std::vector<unsigned char> generateSignature(const std::string& data, const std::string& privateKeyFile) {
    std::ifstream privateKeyStream(privateKeyFile, std::ios::binary);
    if (!privateKeyStream) {
        throw std::runtime_error("无法打开私钥文件: " + privateKeyFile);
    }
    RSA* rsa = PEM_read_RSAPrivateKey(privateKeyStream, nullptr, nullptr, nullptr);
    if (!rsa) {
        handleErrors();
    }

    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, data.c_str(), data.size());
    SHA256_Final(hash, &sha256);

    std::vector<unsigned char> signature(RSA_size(rsa));
    unsigned int sigLen;
    if (RSA_sign(NID_sha256, hash, SHA256_DIGEST_LENGTH, signature.data(), &sigLen, rsa) != 1) {
        handleErrors();
    }
    signature.resize(sigLen);

    RSA_free(rsa);
    return signature;
}

// 验证数字签名
bool verifySignature(const std::string& data, const std::vector<unsigned char>& signature, const std::string& publicKeyFile) {
    std::ifstream publicKeyStream(publicKeyFile, std::ios::binary);
    if (!publicKeyStream) {
        throw std::runtime_error("无法打开公钥文件: " + publicKeyFile);
    }
    RSA* rsa = PEM_read_RSAPublicKey(publicKeyStream, nullptr, nullptr, nullptr);
    if (!rsa) {
        handleErrors();
    }

    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, data.c_str(), data.size());
    SHA256_Final(hash, &sha256);

    int result = RSA_verify(NID_sha256, hash, SHA256_DIGEST_LENGTH, signature.data(), signature.size(), rsa);

    RSA_free(rsa);
    return result == 1;
}

你可以使用以下方式调用上述函数：

cpp 复制代码

int main() {
    // 初始化OpenSSL
    OpenSSL_add_all_algorithms();
    ERR_load_crypto_strings();

    std::string data = "This is the data to be signed";
    std::string privateKeyFile = "private_key.pem";
    std::string publicKeyFile = "public_key.pem";

    std::vector<unsigned char> signature = generateSignature(data, privateKeyFile);

    std::cout << "数字签名: ";
    for (unsigned char c : signature) {
        printf("%02x", c);
    }
    std::cout << std::endl;

    bool isValid = verifySignature(data, signature, publicKeyFile);
    std::cout << "签名验证结果: " << (isValid? "有效" : "无效") << std::endl;

    // 清理OpenSSL
    EVP_cleanup();
    ERR_free_strings();

    return 0;
}

在上述代码中，generateSignature函数首先从私钥文件中读取私钥，然后计算传入数据的 SHA-256 哈希值，接着使用私钥对哈希值进行签名，生成数字签名并返回。verifySignature函数从公钥文件中读取公钥，计算数据的 SHA-256 哈希值，使用公钥对传入的数字签名进行验证，返回验证结果。在main函数中，首先初始化 OpenSSL，然后定义要签名的数据以及私钥和公钥文件路径，生成数字签名并输出，最后验证签名并输出验证结果，最后清理 OpenSSL 环境。通过这些步骤，实现了基于 RSA 和 SHA-256 算法的数字签名生成与验证功能，确保数据的完整性和来源的可靠性。

四、实战项目：文件加密工具

4.1 项目需求（支持 AES 加密文件、RSA 加密 AES 密钥、文件哈希校验）

在当今数字化时代，数据安全愈发重要。为了满足对文件安全存储和传输的需求，我们着手开发一个文件加密工具。该工具的核心功能包括使用 AES 算法对文件进行加密，以确保文件内容的机密性；利用 RSA 算法对 AES 密钥进行加密，增强密钥传输和存储的安全性；以及通过文件哈希校验，保证文件在传输或存储过程中未被篡改，确保数据的完整性。

使用 AES 算法对文件进行加密是工具的基础功能。AES 算法以其高效性和安全性著称，能够快速对文件数据进行加密处理，将文件内容转化为密文形式。这样，即使文件在存储或传输过程中被他人获取，没有正确的密钥也无法读取文件的真实内容，从而有效保护了文件的机密性。例如，在企业内部传输重要的商业文档、财务报表等文件时，使用 AES 加密可以防止文件内容被竞争对手窃取。

RSA 加密 AES 密钥是为了进一步提升密钥的安全性。AES 加密需要使用密钥，而密钥的安全至关重要。通过 RSA 算法对 AES 密钥进行加密，利用 RSA 非对称加密的特性，公钥可以公开用于加密 AES 密钥，只有持有对应私钥的接收方才能解密得到原始的 AES 密钥。这样，在密钥传输过程中，即使加密后的 AES 密钥被截获，由于没有私钥，攻击者也无法还原出原始的 AES 密钥，从而保障了 AES 加密的有效性。比如，在网络通信中，发送方使用接收方的 RSA 公钥加密 AES 密钥，然后将加密后的密钥和 AES 加密后的文件一同发送给接收方，接收方使用自己的私钥解密得到 AES 密钥，再用该密钥解密文件。

文件哈希校验功能则是确保文件完整性的关键。利用哈希算法（如 SHA-256）计算文件的哈希值，这个哈希值就如同文件的 "指纹"，具有唯一性。在文件传输前后或存储过程中，重新计算文件的哈希值并与原始哈希值进行比对，如果两者一致，就说明文件没有被篡改；若不一致，则表明文件可能已被恶意修改，存在安全风险。比如，在软件发布过程中，软件开发者会计算软件文件的哈希值并公布，用户下载软件后可以自行计算哈希值进行比对，以确保下载的软件是完整且未被篡改的。

4.2 OpenSSL 实现加密 / 解密与哈希校验代码

cpp 复制代码

#include <iostream>
#include <fstream>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <openssl/sha.h>
#include <openssl/evp.h>
#include <cstring>
#include <vector>

// 错误处理函数
void handleErrors() {
    ERR_print_errors_fp(stderr);
    abort();
}

// 生成随机AES密钥和IV（初始化向量）
void generateAESKeyAndIV(unsigned char *key, unsigned char *iv) {
    if (!RAND_bytes(key, 32) ||!RAND_bytes(iv, 16)) {
        handleErrors();
    }
}

// AES-256-CBC加密文件
void aesEncryptFile(const std::string& inputFile, const std::string& outputFile, const unsigned char *key, const unsigned char *iv) {
    std::ifstream inFile(inputFile, std::ios::binary);
    std::ofstream outFile(outputFile, std::ios::binary);

    if (!inFile ||!outFile) {
        throw std::runtime_error("无法打开文件");
    }

    EVP_CIPHER_CTX *ctx;
    if (!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
    if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) handleErrors();

    const int bufferSize = 1024;
    unsigned char buffer[bufferSize];
    int len;

    while (inFile.read(reinterpret_cast<char*>(buffer), bufferSize)) {
        unsigned char encryptedBuffer[bufferSize + EVP_CIPHER_CTX_block_size(ctx)];
        if (1 != EVP_EncryptUpdate(ctx, encryptedBuffer, &len, buffer, bufferSize)) handleErrors();
        outFile.write(reinterpret_cast<char*>(encryptedBuffer), len);
    }

    unsigned char encryptedBuffer[bufferSize + EVP_CIPHER_CTX_block_size(ctx)];
    if (1 != EVP_EncryptFinal_ex(ctx, encryptedBuffer, &len)) handleErrors();
    outFile.write(reinterpret_cast<char*>(encryptedBuffer), len);

    EVP_CIPHER_CTX_free(ctx);
    inFile.close();
    outFile.close();
}

// AES-256-CBC解密文件
void aesDecryptFile(const std::string& inputFile, const std::string& outputFile, const unsigned char *key, const unsigned char *iv) {
    std::ifstream inFile(inputFile, std::ios::binary);
    std::ofstream outFile(outputFile, std::ios::binary);

    if (!inFile ||!outFile) {
        throw std::runtime_error("无法打开文件");
    }

    EVP_CIPHER_CTX *ctx;
    if (!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
    if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) handleErrors();

    const int bufferSize = 1024;
    unsigned char buffer[bufferSize];
    int len;

    while (inFile.read(reinterpret_cast<char*>(buffer), bufferSize)) {
        unsigned char decryptedBuffer[bufferSize];
        if (1 != EVP_DecryptUpdate(ctx, decryptedBuffer, &len, buffer, bufferSize)) handleErrors();
        outFile.write(reinterpret_cast<char*>(decryptedBuffer), len);
    }

    unsigned char decryptedBuffer[bufferSize];
    if (1 != EVP_DecryptFinal_ex(ctx, decryptedBuffer, &len)) handleErrors();
    outFile.write(reinterpret_cast<char*>(decryptedBuffer), len);

    EVP_CIPHER_CTX_free(ctx);
    inFile.close();
    outFile.close();
}

// 使用公钥加密AES密钥
std::vector<unsigned char> rsaEncryptKey(const unsigned char *key, int keyLen, const std::string& publicKeyFile) {
    std::ifstream publicKeyStream(publicKeyFile, std::ios::binary);
    if (!publicKeyStream) {
        throw std::runtime_error("无法打开公钥文件");
    }
    RSA* rsa = PEM_read_RSAPublicKey(publicKeyStream, nullptr, nullptr, nullptr);
    if (!rsa) {
        handleErrors();
    }

    std::vector<unsigned char> encryptedKey(RSA_size(rsa));
    int clen = RSA_public_encrypt(keyLen, key, encryptedKey.data(), rsa, RSA_PKCS1_PADDING);
    if (clen == -1) {
        handleErrors();
    }

    RSA_free(rsa);
    encryptedKey.resize(clen);
    return encryptedKey;
}

// 使用私钥解密AES密钥
std::vector<unsigned char> rsaDecryptKey(const std::vector<unsigned char>& encryptedKey, const std::string& privateKeyFile) {
    std::ifstream privateKeyStream(privateKeyFile, std::ios::binary);
    if (!privateKeyStream) {
        throw std::runtime_error("无法打开私钥文件");
    }
    RSA* rsa = PEM_read_RSAPrivateKey(privateKeyStream, nullptr, nullptr, nullptr);
    if (!rsa) {
        handleErrors();
    }

    int clen = encryptedKey.size();
    std::vector<unsigned char> decryptedKey(RSA_size(rsa));
    int flen = RSA_private_decrypt(clen, encryptedKey.data(), decryptedKey.data(), rsa, RSA_PKCS1_PADDING);
    if (flen == -1) {
        handleErrors();
    }

    RSA_free(rsa);
    decryptedKey.resize(flen);
    return decryptedKey;
}

// 计算文件的SHA-256哈希值
std::string calculateFileHash(const std::string& filePath) {
    std::ifstream file(filePath, std::ios::binary);
    if (!file) {
        throw std::runtime_error("无法打开文件: " + filePath);
    }

    file.seekg(0, std::ios::end);
    std::streampos fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    std::vector<char> buffer(fileSize);
    file.read(buffer.data(), fileSize);

    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, buffer.data(), buffer.size());
    SHA256_Final(hash, &sha256);

    std::ostringstream oss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        oss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(hash[i]);
    }

    return oss.str();
}

你可以使用以下方式调用上述函数：

cpp 复制代码

int main() {
    // 初始化OpenSSL
    OpenSSL_add_all_algorithms();
    ERR_load_crypto_strings();

    std::string publicKeyFile = "public_key.pem";
    std::string privateKeyFile = "private_key.pem";
    std::string inputFile = "test.txt";
    std::string encryptedFile = "test_encrypted.txt";
    std::string decryptedFile = "test_decrypted.txt";

    unsigned char aesKey[32];
    unsigned char aesIV[16];
    generateAESKeyAndIV(aesKey, aesIV);

    // 使用AES加密文件
    aesEncryptFile(inputFile, encryptedFile, aesKey, aesIV);

    // 使用RSA加密AES密钥
    std::vector<unsigned char> encryptedAESKey = rsaEncryptKey(aesKey, sizeof(aesKey), publicKeyFile);

    // 计算原始文件的哈希值
    std::string originalHash = calculateFileHash(inputFile);
    std::cout << "原始文件的哈希值: " << originalHash << std::endl;

    // 假设接收到加密文件和加密的AES密钥，进行解密
    std::vector<unsigned char> decryptedAESKey = rsaDecryptKey(encryptedAESKey, privateKeyFile);
    aesDecryptFile(encryptedFile, decryptedFile, decryptedAESKey.data(), aesIV);

    // 计算解密后文件的哈希值
    std::string decryptedHash = calculateFileHash(decryptedFile);
    std::cout << "解密后文件的哈希值: " << decryptedHash << std::endl;

    if (originalHash == decryptedHash) {
        std::cout << "文件哈希校验通过，文件未被篡改" << std::endl;
    } else {
        std::cout << "文件哈希校验失败，文件可能已被篡改" << std::endl;
    }

    // 清理OpenSSL
    EVP_cleanup();
    ERR_free_strings();

    return 0;
}

在上述代码中，generateAESKeyAndIV函数用于生成 AES 加密所需的密钥和初始化向量。aesEncryptFile函数实现了 AES-256-CBC 模式的文件加密，它从输入文件读取数据，分块进行加密后写入输出文件。aesDecryptFile函数则实现了对应的解密操作。rsaEncryptKey函数使用 RSA 公钥对 AES 密钥进行加密，rsaDecryptKey函数使用 RSA 私钥解密被加密的 AES 密钥。calculateFileHash函数用于计算文件的 SHA-256 哈希值。在main函数中，展示了如何调用这些函数来完成文件加密、密钥加密、文件哈希计算以及解密和哈希校验的整个过程。

4.3 加密安全性测试与密钥管理

加密安全性测试是确保文件加密工具可靠性的关键环节。首先，要对加密算法本身进行强度测试，例如使用 AES-256 算法时，需验证其是否能有效抵御常见的攻击手段，如暴力破解、差分攻击等。可以借助专业的密码学测试工具，模拟大量的攻击尝试，观察加密系统的抵御能力。比如，通过不断尝试不同的密钥组合，测试加密算法在面对暴力破解时能够坚持的时间，以评估其安全性。

针对密钥管理，生成密钥时，务必采用高强度的随机数生成器，确保密钥的随机性和不可预测性。使用 OpenSSL 的RAND_bytes函数生成密钥，能有效保证密钥的质量。在密钥存储方面，应将密钥存储在安全的硬件设备中，如硬件安全模块（HSM），或者采用加密文件系统对密钥文件进行存储，并设置严格的访问权限，只有授权人员能够访问。例如，在企业环境中，将密钥存储在专门的 HSM 设备中，通过硬件的加密机制保护密钥，同时设置访问控制列表，只有特定的管理员账户才能操作密钥。

在密钥分发过程中，使用安全的通信协议，如 SSL/TLS，确保密钥在传输过程中不被窃取或篡改。若采用 RSA 加密 AES 密钥的方式，要保证 RSA 密钥对的安全性，定期更换 RSA 密钥对，降低密钥被破解的风险。比如，在网络通信中，发送方使用 SSL/TLS 协议将加密后的 AES 密钥传输给接收方，接收方验证 SSL/TLS 证书的有效性后接收密钥，确保密钥传输的安全。

定期进行密钥轮换也是提高安全性的重要措施。根据安全需求和密钥的使用频率，制定合理的轮换策略，如每月或每季度更换一次 AES 密钥和 RSA 密钥对。在密钥轮换过程中，要确保新旧密钥之间的平滑过渡，避免因密钥更换导致数据无法正常解密。比如，在更换 AES 密钥时，先使用新密钥对新数据进行加密，同时保留旧密钥一段时间，用于解密使用旧密钥加密的数据，待所有相关数据都已更新为新密钥加密后，再彻底删除旧密钥。

通过以上全面的加密安全性测试和严格的密钥管理策略，可以有效提升文件加密工具的安全性，确保文件在加密、存储和传输过程中的安全性和完整性。