C++教程 第46章 安全性编程

第46章 安全性编程

46.1 安全性编程概述

46.1.1 安全性编程的概念

安全性编程是一种编程方法，旨在创建能够抵抗恶意攻击和意外错误的软件。它关注于识别和防范潜在的安全漏洞，确保软件在各种情况下都能安全运行。

46.1.2 安全性编程的重要性

• 保护用户数据：防止敏感信息泄露
• 维护系统完整性：防止系统被篡改
• 确保服务可用性：防止拒绝服务攻击
• 遵守法规要求：满足数据保护法规
• 保护品牌声誉：避免安全事件带来的负面影响
• 减少修复成本：在开发阶段解决安全问题比在部署后修复更经济

46.1.3 C++中的安全挑战

C++是一种强大但复杂的语言，它提供了对硬件的直接访问，同时也带来了一些安全挑战：

• 内存管理：手动内存管理容易导致内存泄漏、缓冲区溢出等问题
• 指针操作：不安全的指针操作可能导致空指针解引用、野指针等问题
• 类型转换：不安全的类型转换可能导致类型错误
• 异常处理：不当的异常处理可能导致资源泄漏
• 并发编程：并发访问共享数据可能导致竞态条件
• 输入验证：缺乏输入验证可能导致注入攻击

46.2 内存安全

46.2.1 内存安全的概念

内存安全是指程序在运行时正确管理内存，避免内存相关的错误，如缓冲区溢出、内存泄漏、空指针解引用等。

46.2.2 常见的内存安全问题

46.2.2.1 缓冲区溢出

缓冲区溢出是指写入的数据超过了缓冲区的大小，导致数据覆盖了相邻的内存区域。

// 不安全的代码
void unsafeFunction(char* input) {
    char buffer[10];
    strcpy(buffer, input); // 危险：如果input长度超过10，会导致缓冲区溢出
}

// 安全的代码
void safeFunction(char* input) {
    char buffer[10];
    strncpy(buffer, input, sizeof(buffer) - 1); // 限制复制的长度
    buffer[sizeof(buffer) - 1] = '\0'; // 确保字符串以null结尾
}

46.2.2.2 内存泄漏

内存泄漏是指程序分配了内存但没有释放，导致内存使用量不断增加。

// 不安全的代码
void leakMemory() {
    int* ptr = new int[100]; // 分配内存
    // 没有释放内存，导致内存泄漏
}

// 安全的代码
void safeMemory() {
    std::unique_ptr<int[]> ptr(new int[100]); // 使用智能指针
    // 智能指针会自动释放内存
}

46.2.2.3 空指针解引用

空指针解引用是指尝试访问空指针指向的内存。

// 不安全的代码
void nullPointerDereference() {
    int* ptr = nullptr;
    *ptr = 42; // 危险：空指针解引用
}

// 安全的代码
void safePointerAccess() {
    int* ptr = nullptr;
    if (ptr != nullptr) {
        *ptr = 42; // 安全：先检查指针是否为空
    }
}

46.2.2.4 野指针

野指针是指指向已释放内存的指针。

// 不安全的代码
void danglingPointer() {
    int* ptr = new int(42);
    delete ptr;
    *ptr = 100; // 危险：野指针解引用
}

// 安全的代码
void safePointerManagement() {
    std::unique_ptr<int> ptr(new int(42));
    // 智能指针会自动管理内存，不会产生野指针
}

46.2.3 内存安全的最佳实践

• 使用智能指针：std::unique_ptr、std::shared_ptr 自动管理内存
• 避免手动内存管理：尽量使用标准容器和智能指针
• 使用std::array和std::vector：替代固定大小的数组
• 使用std::string：替代C风格字符串
• 边界检查：确保所有数组访问都在边界内
• 初始化所有变量：避免使用未初始化的变量
• 使用RAII：资源获取即初始化

46.3 类型安全

46.3.1 类型安全的概念

类型安全是指程序在编译时和运行时都能保持类型的正确性，避免类型错误导致的安全问题。

46.3.2 常见的类型安全问题

46.3.2.1 不安全的类型转换

不安全的类型转换可能导致数据丢失或未定义行为。

// 不安全的代码
void unsafeCast() {
    double d = 3.14;
    int i = (int)d; // C风格强制转换，可能导致数据丢失
}

// 安全的代码
void safeCast() {
    double d = 3.14;
    int i = static_cast<int>(d); // 静态转换，明确意图
    
    // 对于更复杂的转换，使用dynamic_cast
    Base* base = new Derived();
    if (Derived* derived = dynamic_cast<Derived*>(base)) {
        // 安全的转换
    }
}

46.3.2.2 未检查的类型转换

未检查的类型转换可能导致运行时错误。

// 不安全的代码
void uncheckedCast() {
    void* voidPtr = new int(42);
    double* doublePtr = static_cast<double*>(voidPtr); // 危险：未检查的类型转换
    *doublePtr = 3.14; // 可能导致内存损坏
}

// 安全的代码
void checkedCast() {
    std::unique_ptr<int> intPtr(new int(42));
    // 使用正确的类型，避免不必要的类型转换
}

46.3.3 类型安全的最佳实践

• 使用C++风格的类型转换：static_cast、dynamic_cast、const_cast、reinterpret_cast
• 避免reinterpret_cast：除非绝对必要，否则不要使用
• 使用dynamic_cast进行多态转换：并检查转换结果
• 使用强类型枚举：enum class 提供类型安全的枚举
• 使用类型别名：using 关键字创建有意义的类型别名
• 使用模板：提供类型安全的通用代码
• 使用类型 traits：在编译时检查类型特性

46.4 异常安全

46.4.1 异常安全的概念

异常安全是指程序在发生异常时能够保持一致的状态，不会泄露资源或破坏数据。

46.4.2 异常安全的级别

• 基本保证：即使发生异常，程序也能保持一致的状态，没有资源泄漏
• 强保证：如果发生异常，程序状态会回滚到操作前的状态
• 无抛出保证：操作不会抛出任何异常

46.4.3 常见的异常安全问题

46.4.3.1 资源泄漏

异常可能导致资源泄漏，如果资源获取和释放之间发生异常。

// 不安全的代码
void leakResource() {
    File* file = openFile("data.txt");
    processFile(file); // 可能抛出异常
    closeFile(file); // 如果processFile抛出异常，这里不会执行
}

// 安全的代码
void safeResource() {
    std::fstream file("data.txt"); // RAII 资源管理
    processFile(file); // 即使抛出异常，file也会自动关闭
}

46.4.3.2 状态不一致

异常可能导致对象处于不一致的状态。

// 不安全的代码
class BankAccount {
public:
    void transfer(BankAccount& to, double amount) {
        withdraw(amount); // 可能抛出异常
        to.deposit(amount); // 如果withdraw成功但deposit失败，会导致状态不一致
    }
    
    void withdraw(double amount) {
        if (balance < amount) {
            throw InsufficientFundsException();
        }
        balance -= amount;
    }
    
    void deposit(double amount) {
        balance += amount;
    }
    
private:
    double balance;
};

// 安全的代码
class SafeBankAccount {
public:
    void transfer(SafeBankAccount& to, double amount) {
        // 先检查是否有足够的资金
        if (balance < amount) {
            throw InsufficientFundsException();
        }
        
        // 执行转账
        balance -= amount;
        try {
            to.deposit(amount);
        } catch (...) {
            // 如果存款失败，恢复余额
            balance += amount;
            throw; // 重新抛出异常
        }
    }
    
    void deposit(double amount) {
        balance += amount;
    }
    
private:
    double balance;
};

46.4.4 异常安全的最佳实践

• 使用RAII：资源获取即初始化
• 使用智能指针：自动管理内存资源
• 使用标准容器：它们提供异常安全的操作
• 实现强异常安全：使用拷贝-交换 idiom
• 避免在析构函数中抛出异常：析构函数不应该抛出异常
• 使用noexcept：标记不会抛出异常的函数
• 正确处理异常：不要吞掉异常，也不要过度使用异常

46.5 并发安全

46.5.1 并发安全的概念

并发安全是指程序在多线程环境中能够正确运行，避免竞态条件和其他并发相关的问题。

46.5.2 常见的并发安全问题

46.5.2.1 竞态条件

竞态条件是指多个线程同时访问共享数据，导致结果依赖于线程执行的顺序。

// 不安全的代码
class Counter {
public:
    void increment() {
        count++; // 危险：不是原子操作
    }
    
    int getCount() const {
        return count;
    }
    
private:
    int count = 0;
};

// 安全的代码
class SafeCounter {
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mutex);
        count++;
    }
    
    int getCount() const {
        std::lock_guard<std::mutex> lock(mutex);
        return count;
    }
    
private:
    int count = 0;
    mutable std::mutex mutex;
};

// 更现代的实现
class AtomicCounter {
public:
    void increment() {
        count.fetch_add(1, std::memory_order_relaxed);
    }
    
    int getCount() const {
        return count.load(std::memory_order_relaxed);
    }
    
private:
    std::atomic<int> count{0};
};

46.5.2.2 死锁

死锁是指两个或多个线程相互等待对方释放资源，导致所有线程都无法继续执行。

// 不安全的代码
void deadlock-prone() {
    std::mutex mutex1, mutex2;
    
    // 线程1
    std::thread t1([&]() {
        std::lock_guard<std::mutex> lock1(mutex1);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        std::lock_guard<std::mutex> lock2(mutex2);
        // 执行操作
    });
    
    // 线程2
    std::thread t2([&]() {
        std::lock_guard<std::mutex> lock2(mutex2);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        std::lock_guard<std::mutex> lock1(mutex1);
        // 执行操作
    });
    
    t1.join();
    t2.join();
}

// 安全的代码
void deadlock-free() {
    std::mutex mutex1, mutex2;
    
    // 线程1和线程2都以相同的顺序获取锁
    std::thread t1([&]() {
        std::lock_guard<std::mutex> lock1(mutex1);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        std::lock_guard<std::mutex> lock2(mutex2);
        // 执行操作
    });
    
    std::thread t2([&]() {
        std::lock_guard<std::mutex> lock1(mutex1); // 先获取mutex1
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        std::lock_guard<std::mutex> lock2(mutex2); // 再获取mutex2
        // 执行操作
    });
    
    t1.join();
    t2.join();
}

// 更现代的实现
void using-std-lock() {
    std::mutex mutex1, mutex2;
    
    std::thread t1([&]() {
        std::scoped_lock lock(mutex1, mutex2); // 同时获取多个锁
        // 执行操作
    });
    
    std::thread t2([&]() {
        std::scoped_lock lock(mutex1, mutex2); // 同时获取多个锁
        // 执行操作
    });
    
    t1.join();
    t2.join();
}

46.5.2.3 数据竞争

数据竞争是指多个线程同时访问同一内存位置，至少有一个是写入操作，且没有使用同步机制。

// 不安全的代码
int sharedData = 0;

void threadFunction() {
    for (int i = 0; i < 100000; i++) {
        sharedData++; // 危险：数据竞争
    }
}

// 安全的代码
std::atomic<int> atomicData = 0;

void safeThreadFunction() {
    for (int i = 0; i < 100000; i++) {
        atomicData++;
    }
}

46.5.3 并发安全的最佳实践

• 使用互斥锁：std::mutex、std::lock_guard、std::scoped_lock
• 使用原子操作：std::atomic 类型
• 使用线程安全的容器：如 std::atomic 包装的容器
• 避免共享状态：使用消息传递或线程局部存储
• 使用同步原语：std::condition_variable、std::future、std::promise
• 使用线程池：管理线程生命周期
• 避免死锁：以相同的顺序获取锁，使用 std::lock
• 使用无锁数据结构：在高并发场景中提高性能
• 进行并发测试：使用工具检测竞态条件

46.6 输入验证

46.6.1 输入验证的概念

输入验证是指检查用户输入是否符合预期，防止恶意输入导致的安全问题。

46.6.2 常见的输入验证问题

46.6.2.1 缓冲区溢出

恶意输入可能导致缓冲区溢出。

// 不安全的代码
void unsafeInput(char* input) {
    char buffer[100];
    strcpy(buffer, input); // 危险：如果input过长，会导致缓冲区溢出
}

// 安全的代码
void safeInput(char* input) {
    char buffer[100];
    strncpy(buffer, input, sizeof(buffer) - 1);
    buffer[sizeof(buffer) - 1] = '\0';
}

46.6.2.2 注入攻击

恶意输入可能导致注入攻击，如SQL注入。

// 不安全的代码
void unsafeQuery(const std::string& username) {
    std::string query = "SELECT * FROM users WHERE username = '" + username + "'";
    executeQuery(query); // 危险：如果username包含恶意代码，会导致SQL注入
}

// 安全的代码
void safeQuery(const std::string& username) {
    std::string query = "SELECT * FROM users WHERE username = ?";
    executePreparedStatement(query, username); // 使用预处理语句
}

46.6.2.3 命令注入

恶意输入可能导致命令注入。

// 不安全的代码
void unsafeCommand(const std::string& filename) {
    std::string command = "ls -l " + filename;
    system(command.c_str()); // 危险：如果filename包含恶意代码，会导致命令注入
}

// 安全的代码
void safeCommand(const std::string& filename) {
    // 验证文件名
    if (!isValidFilename(filename)) {
        throw std::invalid_argument("Invalid filename");
    }
    
    // 使用安全的方式执行命令
    std::array<char, 128> buffer;
    std::string result;
    std::unique_ptr<FILE, decltype(&pclose)> pipe(popen("ls -l", "r"), pclose);
    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
        result += buffer.data();
    }
    // 处理结果
}

46.6.3 输入验证的最佳实践

• 验证所有输入：包括用户输入、网络数据、文件内容等
• 使用白名单：只接受已知的安全输入
• 使用类型安全的输入：使用适当的类型存储输入
• 限制输入长度：防止缓冲区溢出
• 转义特殊字符：防止注入攻击
• 使用预处理语句：防止SQL注入
• 使用参数化命令：防止命令注入
• 实现输入过滤：移除或转义危险字符
• 进行边界检查：确保输入在有效范围内

46.7 密码学和安全存储

46.7.1 密码学的基本概念

密码学是研究如何安全地传输和存储信息的科学，它包括加密、解密、哈希函数、数字签名等技术。

46.7.2 常见的密码学技术

46.7.2.1 哈希函数

哈希函数将任意长度的数据映射到固定长度的哈希值，用于验证数据完整性和存储密码。

// 使用SHA-256哈希函数
#include <openssl/sha.h>

std::string sha256(const std::string& input) {
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, input.c_str(), input.length());
    SHA256_Final(hash, &sha256);
    
    std::stringstream ss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    }
    return ss.str();
}

// 存储密码哈希
void storePassword(const std::string& username, const std::string& password) {
    // 生成随机盐
    std::string salt = generateRandomSalt();
    // 计算盐值和密码的哈希
    std::string hash = sha256(salt + password);
    // 存储用户名、盐值和哈希
    database.storeUser(username, salt, hash);
}

// 验证密码
bool verifyPassword(const std::string& username, const std::string& password) {
    // 获取用户的盐值和哈希
    auto [salt, hash] = database.getUserCredentials(username);
    // 计算输入密码的哈希
    std::string inputHash = sha256(salt + password);
    // 比较哈希值
    return inputHash == hash;
}

46.7.2.2 加密算法

加密算法用于保护敏感数据，分为对称加密和非对称加密。

// 使用AES对称加密
#include <openssl/aes.h>

std::vector<unsigned char> encryptAES(const std::string& plaintext, const unsigned char* key, const unsigned char* iv) {
    AES_KEY aesKey;
    AES_set_encrypt_key(key, 128, &aesKey);
    
    std::vector<unsigned char> ciphertext(plaintext.size() + AES_BLOCK_SIZE);
    int len = 0;
    int ciphertextLen = 0;
    
    AES_cbc_encrypt(
        reinterpret_cast<const unsigned char*>(plaintext.c_str()),
        ciphertext.data(),
        plaintext.size(),
        &aesKey,
        const_cast<unsigned char*>(iv),
        AES_ENCRYPT
    );
    
    return ciphertext;
}

std::string decryptAES(const std::vector<unsigned char>& ciphertext, const unsigned char* key, const unsigned char* iv) {
    AES_KEY aesKey;
    AES_set_decrypt_key(key, 128, &aesKey);
    
    std::vector<unsigned char> plaintext(ciphertext.size());
    
    AES_cbc_encrypt(
        ciphertext.data(),
        plaintext.data(),
        ciphertext.size(),
        &aesKey,
        const_cast<unsigned char*>(iv),
        AES_DECRYPT
    );
    
    return std::string(reinterpret_cast<char*>(plaintext.data()));
}

46.7.3 安全存储的最佳实践

• 使用强哈希函数：如SHA-256、SHA-3
• 使用盐值：为每个密码生成唯一的盐值
• 使用密钥派生函数：如PBKDF2、bcrypt、Argon2
• 使用HTTPS：保护网络传输
• 使用安全的存储机制：如加密的数据库
• 限制密码尝试次数：防止暴力破解
• 使用多因素认证：提高安全性
• 定期更新密码：减少密码泄露的风险
• 使用密钥管理系统：安全管理加密密钥

46.8 安全编码实践

46.8.1 安全编码的基本原则

• 最小权限原则：程序只应拥有完成任务所需的最小权限
• 防御性编程：假设输入是恶意的，代码是有缺陷的
• 安全默认值：默认配置应该是安全的
• 深度防御：实现多层安全措施
• 保持简单：简单的代码更容易审计和维护
• 代码审计：定期审查代码中的安全问题
• 安全测试：专门测试安全漏洞
• 持续更新：及时应用安全补丁

46.8.2 安全编码的具体实践

46.8.2.1 内存管理

• 使用智能指针：std::unique_ptr、std::shared_ptr
• 使用标准容器：std::vector、std::string 等
• 避免手动内存管理：减少 new 和 delete 的使用
• 实现RAII：资源获取即初始化
• 使用 std::make_unique 和 std::make_shared：避免内存泄漏

46.8.2.2 字符串处理

• 使用 std::string：避免C风格字符串的安全问题
• 使用 std::string::append 和 std::string::assign：安全地操作字符串
• 避免 strcpy、strcat 等不安全的函数：使用 strncpy、strncat 等带长度限制的函数
• 使用 std::regex：安全地处理正则表达式

46.8.2.3 文件操作

• 验证文件路径：防止路径遍历攻击
• 使用 std::fstream：安全地操作文件
• 设置适当的文件权限：限制文件访问权限
• 处理文件操作错误：正确处理文件操作异常
• 避免临时文件：或确保临时文件的安全

46.8.2.4 网络编程

• 使用安全的网络库：如 Boost.Asio
• 验证网络输入：防止注入攻击
• 使用HTTPS：保护网络传输
• 设置超时：防止拒绝服务攻击
• 限制连接数：防止DoS攻击
• 实现速率限制：防止暴力破解

46.8.2.5 系统调用

• 验证系统调用参数：防止注入攻击
• 使用安全的系统调用：避免危险的系统调用
• 处理系统调用错误：正确处理错误返回值
• 使用最小权限：以最低权限运行程序

46.9 安全工具和实践

46.9.1 静态代码分析工具

静态代码分析工具可以在编译时检测潜在的安全问题。

• Clang Static Analyzer：检测内存安全问题
• Cppcheck：检测各种安全问题
• Coverity：商业静态分析工具
• PVS-Studio：检测代码缺陷和安全问题
• SonarQube：代码质量和安全分析

46.9.2 动态分析工具

动态分析工具可以在运行时检测安全问题。

• Valgrind：检测内存泄漏和内存错误
• AddressSanitizer：检测内存错误
• UndefinedBehaviorSanitizer：检测未定义行为
• ThreadSanitizer：检测线程安全问题
• Helgrind：检测线程竞争

46.9.3 安全测试工具

安全测试工具可以模拟攻击，检测安全漏洞。

• OWASP ZAP：Web应用安全测试
• Metasploit：渗透测试框架
• Nmap：网络扫描工具
• Burp Suite：Web应用安全测试
• SQLmap：SQL注入测试

46.9.4 安全实践

• 安全开发生命周期：在整个开发过程中集成安全
• 代码审计：定期审查代码中的安全问题
• 渗透测试：模拟攻击，检测安全漏洞
• 安全培训：提高开发团队的安全意识
• 安全政策：制定和执行安全政策
• 漏洞管理：跟踪和修复安全漏洞
• 事件响应：准备和执行安全事件响应
• 合规性检查：确保符合安全标准和法规

46.10 安全标准和法规

46.10.1 常见的安全标准

• ISO/IEC 27001：信息安全管理体系
• OWASP Top 10：Web应用安全风险
• CWE/SANS Top 25：最危险的软件错误
• NIST Cybersecurity Framework：网络安全框架
• PCI DSS：支付卡行业数据安全标准

46.10.2 常见的安全法规

• GDPR：欧盟通用数据保护条例
• CCPA：加州消费者隐私法案
• HIPAA：健康保险可携性和责任法案
• SOX：萨班斯-奥克斯利法案
• PCI DSS：支付卡行业数据安全标准

46.10.3 合规性要求

• 数据保护：保护个人数据
• 访问控制：限制对敏感信息的访问
• 审计日志：记录安全相关的事件
• 安全测试：定期进行安全测试
• 漏洞管理：及时修复安全漏洞
• 事件响应：准备和执行安全事件响应

46.11 项目实战：安全的用户认证系统

46.11.1 项目需求

• 功能需求：

  • 用户注册
  • 用户登录
  • 密码重置
  • 会话管理
  • 权限控制

• 安全需求：

  • 密码安全存储
  • 防止暴力破解
  • 防止会话劫持
  • 防止SQL注入
  • 防止XSS攻击

46.11.2 技术选型

• 编程语言：C++
• Web框架：Boost.Beast
• 数据库：SQLite
• 密码学库：OpenSSL
• 认证：JWT

46.11.3 系统设计

46.11.3.1 架构设计

• 分层架构：
  • 表示层：处理HTTP请求和响应
  • 业务逻辑层：处理业务逻辑
  • 数据访问层：处理数据库操作
  • 安全层：处理认证和授权

46.11.3.2 关键组件

• 用户管理：处理用户注册、登录、密码重置
• 认证管理：处理JWT令牌的生成和验证
• 权限管理：处理用户权限
• 密码管理：处理密码的哈希和验证
• 会话管理：处理用户会话

46.11.4 代码实现

46.11.4.1 密码管理

#include <openssl/evp.h>
#include <openssl/rand.h>
#include <string>
#include <sstream>
#include <iomanip>

class PasswordManager {
public:
    static std::string generateSalt() {
        unsigned char salt[16];
        RAND_bytes(salt, sizeof(salt));
        return bytesToHex(salt, sizeof(salt));
    }
    
    static std::string hashPassword(const std::string& password, const std::string& salt) {
        unsigned char hash[EVP_MAX_MD_SIZE];
        unsigned int hashLen;
        
        EVP_MD_CTX* ctx = EVP_MD_CTX_new();
        EVP_DigestInit_ex(ctx, EVP_sha256(), nullptr);
        EVP_DigestUpdate(ctx, salt.c_str(), salt.length());
        EVP_DigestUpdate(ctx, password.c_str(), password.length());
        EVP_DigestFinal_ex(ctx, hash, &hashLen);
        EVP_MD_CTX_free(ctx);
        
        return bytesToHex(hash, hashLen);
    }
    
    static bool verifyPassword(const std::string& password, const std::string& salt, const std::string& hash) {
        std::string computedHash = hashPassword(password, salt);
        return computedHash == hash;
    }
    
private:
    static std::string bytesToHex(const unsigned char* bytes, size_t length) {
        std::stringstream ss;
        for (size_t i = 0; i < length; i++) {
            ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(bytes[i]);
        }
        return ss.str();
    }
};

46.11.4.2 用户管理

#include <sqlite3.h>
#include <string>
#include <stdexcept>
#include "PasswordManager.h"

class UserManager {
public:
    UserManager(const std::string& dbPath) {
        int rc = sqlite3_open(dbPath.c_str(), &db);
        if (rc != SQLITE_OK) {
            throw std::runtime_error("Failed to open database");
        }
        createTable();
    }
    
    ~UserManager() {
        sqlite3_close(db);
    }
    
    void registerUser(const std::string& username, const std::string& password, const std::string& email) {
        // 验证输入
        if (username.empty() || password.empty() || email.empty()) {
            throw std::invalid_argument("Username, password, and email are required");
        }
        
        // 检查用户名是否已存在
        if (userExists(username)) {
            throw std::invalid_argument("Username already exists");
        }
        
        // 生成盐值和哈希
        std::string salt = PasswordManager::generateSalt();
        std::string hash = PasswordManager::hashPassword(password, salt);
        
        // 插入用户
        std::string sql = "INSERT INTO users (username, salt, hash, email) VALUES (?, ?, ?, ?)";
        sqlite3_stmt* stmt;
        int rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr);
        if (rc != SQLITE_OK) {
            throw std::runtime_error("Failed to prepare statement");
        }
        
        sqlite3_bind_text(stmt, 1, username.c_str(), -1, SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 2, salt.c_str(), -1, SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 3, hash.c_str(), -1, SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 4, email.c_str(), -1, SQLITE_TRANSIENT);
        
        rc = sqlite3_step(stmt);
        if (rc != SQLITE_DONE) {
            sqlite3_finalize(stmt);
            throw std::runtime_error("Failed to insert user");
        }
        
        sqlite3_finalize(stmt);
    }
    
    bool loginUser(const std::string& username, const std::string& password) {
        // 验证输入
        if (username.empty() || password.empty()) {
            return false;
        }
        
        // 获取用户信息
        std::string salt, hash;
        if (!getUserCredentials(username, salt, hash)) {
            return false;
        }
        
        // 验证密码
        return PasswordManager::verifyPassword(password, salt, hash);
    }
    
private:
    sqlite3* db;
    
    void createTable() {
        std::string sql = "CREATE TABLE IF NOT EXISTS users (" 
                         "id INTEGER PRIMARY KEY AUTOINCREMENT, " 
                         "username TEXT UNIQUE NOT NULL, " 
                         "salt TEXT NOT NULL, " 
                         "hash TEXT NOT NULL, " 
                         "email TEXT UNIQUE NOT NULL, " 
                         "created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP);";
        char* errMsg;
        int rc = sqlite3_exec(db, sql.c_str(), nullptr, nullptr, &errMsg);
        if (rc != SQLITE_OK) {
            std::string error = errMsg;
            sqlite3_free(errMsg);
            throw std::runtime_error("Failed to create table: " + error);
        }
    }
    
    bool userExists(const std::string& username) {
        std::string sql = "SELECT id FROM users WHERE username = ?";
        sqlite3_stmt* stmt;
        int rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr);
        if (rc != SQLITE_OK) {
            throw std::runtime_error("Failed to prepare statement");
        }
        
        sqlite3_bind_text(stmt, 1, username.c_str(), -1, SQLITE_TRANSIENT);
        rc = sqlite3_step(stmt);
        bool exists = (rc == SQLITE_ROW);
        sqlite3_finalize(stmt);
        return exists;
    }
    
    bool getUserCredentials(const std::string& username, std::string& salt, std::string& hash) {
        std::string sql = "SELECT salt, hash FROM users WHERE username = ?";
        sqlite3_stmt* stmt;
        int rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr);
        if (rc != SQLITE_OK) {
            throw std::runtime_error("Failed to prepare statement");
        }
        
        sqlite3_bind_text(stmt, 1, username.c_str(), -1, SQLITE_TRANSIENT);
        rc = sqlite3_step(stmt);
        if (rc != SQLITE_ROW) {
            sqlite3_finalize(stmt);
            return false;
        }
        
        salt = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
        hash = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
        sqlite3_finalize(stmt);
        return true;
    }
};

46.11.4.3 认证管理

#include <jwt-cpp/jwt.h>
#include <string>
#include <chrono>

class AuthManager {
public:
    AuthManager(const std::string& secretKey) : secretKey(secretKey) {}
    
    std::string generateToken(const std::string& username) {
        auto now = std::chrono::system_clock::now();
        auto expiration = now + std::chrono::hours(24); // 令牌有效期24小时
        
        auto token = jwt::create()
            .set_issuer("auth-server")
            .set_subject(username)
            .set_issued_at(now)
            .set_expires_at(expiration)
            .sign(jwt::algorithm::hs256{secretKey});
        
        return token;
    }
    
    bool validateToken(const std::string& token, std::string& username) {
        try {
            auto decoded = jwt::decode(token);
            auto verifier = jwt::verify()
                .with_issuer("auth-server")
                .with_algorithm(jwt::algorithm::hs256{secretKey});
            verifier.verify(decoded);
            
            username = decoded.get_subject();
            return true;
        } catch (const std::exception& e) {
            return false;
        }
    }
    
private:
    std::string secretKey;
};

46.11.5 测试与验证

• 功能测试：测试用户注册、登录、密码重置等功能
• 安全测试：
  • 密码安全存储测试
  • 暴力破解防护测试
  • SQL注入测试
  • XSS攻击测试
  • 会话劫持测试
• 性能测试：测试系统在高负载下的性能
• 合规性测试：确保符合安全标准和法规

46.11.6 项目总结

本项目实现了一个安全的用户认证系统，具有以下特点：

• 密码安全存储：使用盐值和SHA-256哈希函数
• 防止SQL注入：使用参数化查询
• 防止暴力破解：可以添加登录尝试限制
• 安全的会话管理：使用JWT令牌
• 分层架构：清晰的代码结构
• 错误处理：适当的异常处理

通过本项目的实践，我们学习了安全性编程的核心概念和技术，包括密码学、输入验证、异常安全、并发安全等，为开发更安全的C++应用程序打下了基础。

46.12 小结

本章介绍了C++安全性编程的相关知识，包括：

• 安全性编程概述：安全性编程的概念、重要性和C++中的安全挑战
• 内存安全：缓冲区溢出、内存泄漏、空指针解引用、野指针等问题及解决方案
• 类型安全：不安全的类型转换、未检查的类型转换等问题及解决方案
• 异常安全：资源泄漏、状态不一致等问题及解决方案
• 并发安全：竞态条件、死锁、数据竞争等问题及解决方案
• 输入验证：缓冲区溢出、注入攻击、命令注入等问题及解决方案
• 密码学和安全存储：哈希函数、加密算法、安全存储的最佳实践
• 安全编码实践：安全编码的基本原则和具体实践
• 安全工具和实践：静态分析工具、动态分析工具、安全测试工具和安全实践
• 安全标准和法规：常见的安全标准和法规
• 项目实战：安全的用户认证系统的设计与实现

安全性编程是C++编程中的重要主题，它关系到软件的可靠性、安全性和用户信任。通过学习和应用安全性编程的技术和最佳实践，我们可以开发出更安全、更可靠的C++应用程序，保护用户数据和系统安全。

同时，安全性编程是一个持续的过程，需要我们不断学习和更新知识，以应对新的安全威胁和挑战。我们应该将安全性编程的理念融入到软件开发的各个阶段，从需求分析到设计、编码、测试和维护，确保软件的安全性贯穿整个生命周期。