第62章 STL与加密

课程目录第62章 STL与加密

STL与加密：对称加密、非对称加密、哈希算法

说实话，很多C++开发者一听到「加密」两个字，第一反应就是「这玩意儿不是应该用OpenSSL吗？跟STL有什么关系？」

嗯，这个想法我也有过。早些年我在做一个嵌入式通信模块的时候，项目要求不能用第三方库，所有加密逻辑必须手写。那时候我才真正意识到——STL里的容器、算法、迭代器，其实能帮我们写出非常优雅的加密代码。

今天我们就来聊聊，怎么用STL的思路去理解三种核心加密手段：对称加密、非对称加密、哈希算法。说白了，就是让你以后写加密代码时，脑子里想的是std::vector和std::transform，而不是一堆裸指针和魔数。

一、对称加密：用STL实现XOR流密码

对称加密的核心思想很简单：加密和解密用同一个密钥。最常见的例子就是XOR加密。

你可能会说：「XOR加密太弱了吧？」没错，单纯的XOR确实弱，但它的思想是所有流密码的基础。我在项目中曾经用XOR做临时数据的快速混淆，不是为了防黑客，而是为了防止调试日志里明文泄露敏感字段。

来看一个用STL实现的XOR加密器：

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <iterator>

class XORCipher {
public:
    explicit XORCipher(const std::vector<uint8_t>& key) : key_(key) {}

    std::vector<uint8_t> encrypt(const std::vector<uint8_t>& plaintext) {
        std::vector<uint8_t> result(plaintext.size());
        std::transform(plaintext.begin(), plaintext.end(),
                       key_.begin(), result.begin(),
                       [this](uint8_t p, uint8_t k) {
                           return p ^ k;
                       });
        return result;
    }

    // 解密就是再次XOR
    std::vector<uint8_t> decrypt(const std::vector<uint8_t>& ciphertext) {
        return encrypt(ciphertext);
    }

private:
    std::vector<uint8_t> key_;
};

int main() {
    std::vector<uint8_t> key = {0x1A, 0x2B, 0x3C, 0x4D};
    XORCipher cipher(key);

    std::string msg = "Hello STL!";
    std::vector<uint8_t> plaintext(msg.begin(), msg.end());

    auto encrypted = cipher.encrypt(plaintext);
    auto decrypted = cipher.decrypt(encrypted);

    std::string result(decrypted.begin(), decrypted.end());
    std::cout << "解密结果: " << result << std::endl;
    return 0;
}

关键点：这里用了std::transform，把加密变成了一个「逐元素映射」的操作。密钥长度不够时，可以用std::next_permutation循环复用，或者用std::rotate做密钥滚动。

我的习惯：对称加密的密钥管理才是真正的难点。我一般用std::array<uint8_t, 32>来固定密钥长度，避免动态分配带来的侧信道风险。

二、非对称加密：RSA核心步骤的STL表达

非对称加密就复杂多了。它用一对密钥：公钥加密，私钥解密。RSA是最经典的实现。

RSA的数学原理涉及大素数、模幂运算。但如果我们只关注「数据怎么组织」，STL的std::vector和std::multiset其实能帮上大忙。

举个例子，RSA加密时要把明文分成块，每块大小不能超过模数。这个分块操作，用STL写起来非常自然：

#include <iostream>
#include <vector>
#include <cstdint>
#include <algorithm>

// 模拟RSA分块：将字节流按块大小分割
std::vector<std::vector<uint8_t>> split_into_blocks(
    const std::vector<uint8_t>& data, size_t block_size) {

    std::vector<std::vector<uint8_t>> blocks;
    for (size_t i = 0; i < data.size(); i += block_size) {
        auto end = std::min(i + block_size, data.size());
        blocks.emplace_back(data.begin() + i, data.begin() + end);
    }
    return blocks;
}

// 用std::accumulate模拟模幂运算（仅教学演示）
uint64_t mod_pow(uint64_t base, uint64_t exp, uint64_t mod) {
    uint64_t result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) result = (result * base) % mod;
        base = (base * base) % mod;
        exp >>= 1;
    }
    return result;
}

int main() {
    std::vector<uint8_t> message = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
    size_t block_size = 4;

    auto blocks = split_into_blocks(message, block_size);
    std::cout << "分块数量: " << blocks.size() << std::endl;

    // 模拟公钥 (n=3233, e=17)
    uint64_t n = 3233, e = 17;
    for (const auto& block : blocks) {
        uint64_t plain = 0;
        for (auto b : block) plain = (plain << 8) | b;
        uint64_t cipher = mod_pow(plain, e, n);
        std::cout << "加密块: " << cipher << std::endl;
    }
    return 0;
}

我曾经踩过的坑：非对称加密的性能开销非常大。有一次我在一个高并发服务里直接用RSA加密每个请求的payload，结果CPU直接飙到100%。后来改成「用RSA交换对称密钥，后续用AES加密数据」，性能提升了20倍。记住：非对称加密只用来加密密钥或签名，别用来加密大数据。

三、哈希算法：STL容器与哈希的天然结合

哈希算法不是加密，但它和加密经常一起出现。它的特点是：不可逆、定长输出、雪崩效应。

STL里其实已经内置了哈希函数——std::hash。但std::hash主要用于std::unordered_map，它的强度不足以用于密码学场景。

不过，我们可以用STL的std::accumulate和std::transform来实现一个简单的「校验和哈希」，用来理解哈希的本质：

#include <iostream>
#include <vector>
#include <string>
#include <numeric>
#include <functional>

// 一个简单的Fowler-Noll-Vo哈希（FNV-1a）
uint32_t fnv1a_hash(const std::vector<uint8_t>& data) {
    const uint32_t FNV_PRIME = 16777619u;
    const uint32_t FNV_OFFSET = 2166136261u;

    return std::accumulate(data.begin(), data.end(), FNV_OFFSET,
        [](uint32_t hash, uint8_t byte) {
            hash ^= byte;
            hash *= FNV_PRIME;
            return hash;
        });
}

int main() {
    std::string input = "Hello, STL Hash!";
    std::vector<uint8_t> data(input.begin(), input.end());

    uint32_t hash1 = fnv1a_hash(data);
    uint32_t hash2 = fnv1a_hash(data);

    std::cout << "哈希值: " << hash1 << std::endl;
    std::cout << "一致性验证: " << (hash1 == hash2 ? "通过" : "失败") << std::endl;

    // 修改一个字节，观察雪崩效应
    data[0] ^= 0x01;
    uint32_t hash3 = fnv1a_hash(data);
    std::cout << "修改后哈希: " << hash3 << std::endl;
    std::cout << "差异位数: " << __builtin_popcount(hash1 ^ hash3) << std::endl;
    return 0;
}

注意：FNV-1a不是密码学安全的哈希，它不能抵抗碰撞攻击。真正的密码学哈希如SHA-256，需要复杂的位运算和轮函数。但用STL理解哈希的「折叠」思想，这个例子足够了。

四、三种加密的对比与选择

我整理了一张表，方便你快速对比：

特性	对称加密	非对称加密	哈希算法
密钥数量	1个（共享密钥）	2个（公钥+私钥）	无密钥
速度	快（适合大数据）	慢（适合小数据）	快（定长输出）
可逆性	可逆	可逆（私钥解密）	不可逆
典型算法	AES, ChaCha20	RSA, ECC	SHA-256, BLAKE2
STL常用组件	`std::transform`, `std::vector`	`std::vector`, `std::accumulate`	`std::accumulate`, `std::hash`
典型用途	文件加密、通信加密	密钥交换、数字签名	数据完整性、密码存储

五、知识体系总览

下面这张SVG图，把三种加密的核心流程和STL的对应关系画出来了。你看一眼就能明白整体结构：

我的建议：如果你刚开始接触加密，先从对称加密和哈希入手。非对称加密的数学门槛稍高，但用STL的容器来管理密钥对和证书链，代码会清晰很多。我在做PKI证书解析时，用std::map<std::string, std::string>来存储证书字段，比手写链表舒服太多了。

最后说一句：STL不是加密库，但它提供了优秀的数据结构和算法骨架。你完全可以用STL搭建出加密模块的「基础设施」，然后把核心密码学运算交给专门的库（如OpenSSL、Crypto++）。这种分层设计，我在多个生产项目中验证过，非常靠谱。

📚 课程目录

STL与加密：对称加密、非对称加密、哈希算法

一、对称加密：用STL实现XOR流密码

二、非对称加密：RSA核心步骤的STL表达

三、哈希算法：STL容器与哈希的天然结合

四、三种加密的对比与选择

五、知识体系总览