C++如何在Linux实现文件加密

发布时间:2025-07-22 05:13:02

阅读量:73

在Linux下使用C++实现文件加密，可以采用多种方法。以下介绍两种常用的方法：

使用OpenSSL库进行加密
使用AES-NI指令集进行硬件加速加密

方法一：使用OpenSSL库进行加密

OpenSSL是一个强大的加密库，支持多种加密算法和协议。通过C++调用OpenSSL库，可以方便地实现文件的加密和解密。

步骤：

安装OpenSSL开发库

在大多数Linux发行版中，可以使用包管理器安装OpenSSL的开发库。例如，在Ubuntu上：
```
sudo apt-get update
sudo apt-get install libssl-dev
```

编写C++代码

下面是一个使用OpenSSL的AES-256-CBC算法对文件进行加密和解密的示例代码：

#include 
#include 
#include 
#include 
#include 

// 加密函数
bool encryptFile(const std::string& inputFile, const std::string& outputFile, const std::string& password) {
    // 读取输入文件
    std::ifstream inFile(inputFile, std::ios::binary);
    if (!inFile) {
        std::cerr << "无法打开输入文件。" << std class="hljs-keyword">return false;
    }

    // 写入输出文件
    std::ofstream outFile(outputFile, std::ios::binary);
    if (!outFile) {
        std::cerr << "无法打开输出文件。" << std class="hljs-keyword">return false;
    }

    // 生成随机的盐
    unsigned char salt[8];
    if (!RAND_bytes(salt, sizeof(salt))) {
        std::cerr << "生成盐失败。" << std class="hljs-keyword">return false;
    }
    outFile.write(reinterpret_cast<const char*>(salt), sizeof(salt));

    // 使用PBKDF2从密码派生密钥
    AES_KEY enc_key;
    unsigned char key[32]; // AES-256
    if (!PKCS5_PBKDF2_HMAC(password.c_str(), password.size(),
                           salt, sizeof(salt),
                           10000, AES_KEYLEN_256, EVP_sha256(), sizeof(key), key)) {
        std::cerr << "密钥派生失败。" << std class="hljs-keyword">return false;
    }

    // 初始化加密上下文
    if (!AES_set_encrypt_key(key, 256, &enc_key)) {
        std::cerr << "设置加密密钥失败。" << std class="hljs-keyword">return false;
    }

    // 写入IV（初始化向量）
    unsigned char iv[AES_BLOCK_SIZE];
    if (!RAND_bytes(iv, sizeof(iv))) {
        std::cerr << "生成IV失败。" << std class="hljs-keyword">return false;
    }
    outFile.write(reinterpret_cast<const char*>(iv), sizeof(iv));

    // 加密数据
    char inbuf[AES_BLOCK_SIZE];
    char outbuf[AES_BLOCK_SIZE + AES_BLOCK_SIZE];
    while (inFile.good()) {
        inFile.read(inbuf, sizeof(inbuf));
        size_t bytesRead = inFile.gcount();
        if (bytesRead > 0) {
            AES_cbc_encrypt(inbuf, outbuf, bytesRead, &enc_key, iv, AES_ENCRYPT);
            outFile.write(outbuf, sizeof(outbuf));
        }
    }

    inFile.close();
    outFile.close();
    return true;
}

// 解密函数
bool decryptFile(const std::string& inputFile, const std::string& outputFile, const std::string& password) {
    // 打开输入文件
    std::ifstream inFile(inputFile, std::ios::binary);
    if (!inFile) {
        std::cerr << "无法打开输入文件。" << std class="hljs-keyword">return false;
    }

    // 打开输出文件
    std::ofstream outFile(outputFile, std::ios::binary);
    if (!outFile) {
        std::cerr << "无法打开输出文件。" << std class="hljs-keyword">return false;
    }

    // 读取盐
    unsigned char salt[8];
    inFile.read(reinterpret_cast<char*>(salt), sizeof(salt));
    if (!inFile) {
        std::cerr << "读取盐失败。" << std class="hljs-keyword">return false;
    }

    // 读取IV
    unsigned char iv[AES_BLOCK_SIZE];
    inFile.read(reinterpret_cast<char*>(iv), sizeof(iv));
    if (!inFile) {
        std::cerr << "读取IV失败。" << std class="hljs-keyword">return false;
    }

    // 使用PBKDF2从密码派生密钥
    AES_KEY dec_key;
    unsigned char key[32]; // AES-256
    if (!PKCS5_PBKDF2_HMAC(password.c_str(), password.size(),
                           salt, sizeof(salt),
                           10000, AES_KEYLEN_256, EVP_sha256(), sizeof(key), key)) {
        std::cerr << "密钥派生失败。" << std class="hljs-keyword">return false;
    }

    // 初始化解密上下文
    if (!AES_set_decrypt_key(key, 256, &dec_key)) {
        std::cerr << "设置解密密钥失败。" << std class="hljs-keyword">return false;
    }

    // 解密数据
    char inbuf[AES_BLOCK_SIZE + AES_BLOCK_SIZE];
    char outbuf[AES_BLOCK_SIZE];
    while (inFile.good()) {
        inFile.read(inbuf, sizeof(inbuf));
        size_t bytesRead = inFile.gcount();
        if (bytesRead > 0) {
            AES_cbc_encrypt(inbuf, outbuf, bytesRead, &dec_key, iv, AES_DECRYPT);
            outFile.write(outbuf, bytesRead);
        }
    }

    inFile.close();
    outFile.close();
    return true;
}

int main(int argc, char* argv[]) {
    if (argc != 4) {
        std::cerr << "用法: " << argv class="hljs-number">0] << " encrypt|decrypt 输入文件 输出文件 密码" << std class="hljs-keyword">return 1;
    }

    std::string mode = argv[1];
    std::string inputFile = argv[2];
    std::string outputFile = argv[3];
    std::string password = argv[4];

    if (mode == "encrypt") {
        if (encryptFile(inputFile, outputFile, password)) {
            std::cout << "加密成功。" << std class="hljs-keyword">else {
            std::cerr << "加密失败。" << std class="hljs-keyword">else if (mode == "decrypt") {
        if (decryptFile(inputFile, outputFile, password)) {
            std::cout << "解密成功。" << std class="hljs-keyword">else {
            std::cerr << "解密失败。" << std class="hljs-keyword">else {
        std::cerr << "未知模式。使用encrypt或decrypt。" << std class="hljs-keyword">return 1;
    }

    return 0;
}

编译代码

使用g++编译时，需要链接OpenSSL的加密库：
```
g++ -o file_encrypt file_encrypt.cpp -lcrypto
```

使用示例

# 加密文件
./file_encrypt encrypt plaintext.txt encrypted.bin mypassword

# 解密文件
./file_encrypt decrypt encrypted.bin decrypted.txt mypassword

说明：

盐（Salt）：用于增加密钥派生的安全性，防止彩虹表攻击。
密钥派生函数（PBKDF2）：通过多次哈希密码和盐，生成强加密密钥。
初始化向量（IV）：保证相同的明文在不同的加密过程中生成不同的密文，增强安全性。
AES-256-CBC：使用256位AES算法和CBC模式进行加密。

方法二：使用AES-NI指令集进行硬件加速加密

如果您的CPU支持AES-NI指令集，可以利用硬件加速来提高加密和解密的性能。下面介绍如何使用C++和Intel的Intel Intrinsics来实现AES加密。

步骤：

安装必要的开发工具

确保已安装GCC和相关的开发工具。大多数Linux发行版默认已安装。

编写C++代码

下面是一个使用AES-NI指令集进行AES-256-CBC加密和解密的示例代码：

#include 
#include 
#include 
#include  // 包含AES-NI指令集头文件

// 加密函数
bool aesni_encrypt_file(const std::string& inputFile, const std::string& outputFile, const unsigned char* key, const unsigned char* iv) {
    // 打开输入文件
    std::ifstream inFile(inputFile, std::ios::binary);
    if (!inFile) {
        std::cerr << "无法打开输入文件。" << std class="hljs-keyword">return false;
    }

    // 打开输出文件
    std::ofstream outFile(outputFile, std::ios::binary);
    if (!outFile) {
        std::cerr << "无法打开输出文件。" << std class="hljs-keyword">return false;
    }

    // 写入IV
    outFile.write(reinterpret_cast<const char*>(iv), AES_BLOCK_SIZE);

    // 加密缓冲区
    const int bufferSize = 4096; // 4KB缓冲区
    unsigned char inbuf[bufferSize];
    unsigned char outbuf[bufferSize + AES_BLOCK_SIZE];

    while (inFile.good()) {
        inFile.read(reinterpret_cast<char*>(inbuf), sizeof(inbuf));
        size_t bytesRead = inFile.gcount();

        if (bytesRead > 0) {
            // AES-NI加密
            for (size_t i = 0; i < bytesRead xss=removed xss=removed class="hljs-built_in">reinterpret_cast<const __m128i*>(key));
                __m128i aes_iv = _mm_loadu_si128(reinterpret_cast<const __m128i*>(iv));

                __m128i in = _mm_loadu_si128(reinterpret_cast<const __m128i*>(inbuf + i));
                __m128i out = _mm_aesenc_si128(in, aes_key);
                out = _mm_aesenc_si128(out, aes_key);
                out = _mm_aesenc_si128(out, aes_key);
                out = _mm_aesenclast_si128(out, aes_key);

                _mm_storeu_si128(reinterpret_cast<__m128i*>(outbuf + i), out);
            }

            outFile.write(reinterpret_cast<const char*>(outbuf), sizeof(outbuf));
        }
    }

    inFile.close();
    outFile.close();
    return true;
}

// 解密函数
bool aesni_decrypt_file(const std::string& inputFile, const std::string& outputFile, const unsigned char* key, const unsigned char* iv) {
    // 打开输入文件
    std::ifstream inFile(inputFile, std::ios::binary);
    if (!inFile) {
        std::cerr << "无法打开输入文件。" << std class="hljs-keyword">return false;
    }

    // 打开输出文件
    std::ofstream outFile(outputFile, std::ios::binary);
    if (!outFile) {
        std::cerr << "无法打开输出文件。" << std class="hljs-keyword">return false;
    }

    // 读取IV
    unsigned char read_iv[AES_BLOCK_SIZE];
    inFile.read(reinterpret_cast<char*>(read_iv), sizeof(read_iv));
    if (!inFile) {
        std::cerr << "读取IV失败。" << std class="hljs-keyword">return false;
    }

    // 检查IV是否匹配
    if (memcmp(read_iv, iv, AES_BLOCK_SIZE) != 0) {
        std::cerr << "IV不匹配。" << std class="hljs-keyword">return false;
    }

    // 解密缓冲区
    const int bufferSize = 4096; // 4KB缓冲区
    unsigned char inbuf[bufferSize + AES_BLOCK_SIZE];
    unsigned char outbuf[bufferSize];

    while (inFile.good()) {
        inFile.read(reinterpret_cast<char*>(inbuf), sizeof(inbuf));
        size_t bytesRead = inFile.gcount();

        if (bytesRead > 0) {
            // AES-NI解密
            for (size_t i = 0; i < bytesRead xss=removed xss=removed class="hljs-built_in">reinterpret_cast<const __m128i*>(key));
                __m128i in = _mm_loadu_si128(reinterpret_cast<const __m128i*>(inbuf + i));
                __m128i out = _mm_aesdec_si128(in, aes_key);
                out = _mm_aesdec_si128(out, aes_key);
                out = _mm_aesdec_si128(out, aes_key);
                out = _mm_aesdeclast_si128(out, aes_key);

                _mm_storeu_si128(reinterpret_cast<__m128i*>(outbuf + i), out);
            }

            outFile.write(reinterpret_cast<const char*>(outbuf), sizeof(outbuf));
        }
    }

    inFile.close();
    outFile.close();
    return true;
}

int main(int argc, char* argv[]) {
    if (argc != 5) {
        std::cerr << "用法: " << argv class="hljs-number">0] << " encrypt|decrypt 输入文件 输出文件 密钥 密码" << std class="hljs-keyword">return 1;
    }

    std::string mode = argv[1];
    std::string inputFile = argv[2];
    std::string outputFile = argv[3];
    std::string password = argv[4];

    // 密钥派生（简单示例，使用PBKDF2需要额外实现）
    // 这里假设已经有一个256位的密钥
    unsigned char key[32] = { /* 256位密钥 */ };
    unsigned char iv[AES_BLOCK_SIZE] = { /* 128位IV */ };

    if (mode == "encrypt") {
        if (aesni_encrypt_file(inputFile, outputFile, key, iv)) {
            std::cout << "加密成功。" << std class="hljs-keyword">else {
            std::cerr << "加密失败。" << std class="hljs-keyword">else if (mode == "decrypt") {
        if (aesni_decrypt_file(inputFile, outputFile, key, iv)) {
            std::cout << "解密成功。" << std class="hljs-keyword">else {
            std::cerr << "解密失败。" << std class="hljs-keyword">else {
        std::cerr << "未知模式。使用encrypt或decrypt。" << std class="hljs-keyword">return 1;
    }

    return 0;
}

注意：

密钥管理：示例中硬编码了密钥和IV，实际应用中应安全地生成和存储密钥。可以使用OpenSSL或其他库生成密钥，并通过安全的方式传递给程序。
IV管理：每次加密应使用不同的IV，确保相同的明文加密后结果不同。IV不需要保密，但必须唯一。
填充方式：AES-CBC模式要求数据长度为块大小的倍数，因此需要对数据进行填充（如PKCS#7）。上述示例代码未处理填充，实际应用中需要添加。

编译代码

使用g++编译时，可以启用AES-NI指令集优化：
```
g++ -o aesni_encrypt aesni_encrypt.cpp -mavx2
```
-mavx2选项启用了AVX2指令集，包括AES-NI。如果您的CPU支持AES-NI但不支持AVX2，可以省略该选项或使用其他相关选项。

使用示例

# 加密文件
./aesni_encrypt encrypt plaintext.txt encrypted.bin

# 解密文件
./aesni_encrypt decrypt encrypted.bin decrypted.txt

说明：

AES-NI指令集：现代Intel和AMD处理器支持AES-NI指令集，能够显著提高AES加密和解密的速度。
性能优势：利用硬件加速，AES-NI可以在不增加太多编程复杂度的情况下提升加密性能。
安全性：确保密钥和IV的安全管理，避免泄露导致的安全风险。

总结

以上介绍了两种在Linux下使用C++实现文件加密的方法：

OpenSSL库：适用于需要跨平台支持、灵活选择加密算法和模式的场景。通过调用OpenSSL库，可以方便地实现复杂的加密需求。
AES-NI指令集：适用于对性能有较高要求，并且运行在支持AES-NI硬件的服务器上的应用。利用硬件加速，可以大幅提升加密和解密的效率。

根据具体需求选择合适的方法，并注意密钥管理和数据安全。

C++如何在Linux实现文件加密

方法一：使用OpenSSL库进行加密

步骤：

说明：

方法二：使用AES-NI指令集进行硬件加速加密

步骤：

说明：

总结

相关文章