actpred: 代码审计（16项发现全部修复）+ 文档更新

审计报告: docs/reviews/actpred_CODE_AUDIT_20260808.md
- P0(2项): episode索引错位(dataset.py)、推理归一化静默失败(predict.py)
- P1(6项): 空训练集校验、图像自然排序、空样本防御、形状校验、
  MobileNet下载错误提示、stats路径校验
- P2(8项): README示例修正、公共属性、glob优化、版本约束、
  单元测试(17项)、GPU安装说明、BooleanOptionalAction、ONNX验证

新增文件: actpred/test_actpred.py (17项单元测试, 全部通过)
更新文档: README.md配置表扩充、INDEX.md、审计报告修复总结

libcrypt/Makefile

@@ -1,4 +1,4 @@
-VERSION := 0.0.1
+VERSION := 0.0.2
 FRAMEWORK_NAME := us
 LIB_NAME := libus_crypt
 INSTL_TDIR := /lib

libcrypt/README.md

@@ -34,9 +34,11 @@ qing::Crypto_Basic          (基类: bytes_to_hex / hex_to_bytes / CRYPTO_CHECK)
 
 ### AES_CBC — AES-256-CBC 对称加密
 
+> ⚠️ **CBC 模式存在结构性安全缺陷**（无完整性保护、Padding Oracle、IV 重用风险）。详见 [CBC 迁移开发文档](../docs/reports/libcrypt_CBC_deprecation_dev_doc.md)。新代码建议使用 AES-GCM（待实现），现有 `AES_CBC` 保留以兼容存量代码。
+
 ```cpp
 AES_CBC aes;                           // 自动生成随机 32B 密钥 + 16B IV
-AES_CBC aes(key_vec, iv_vec);          // 使用外部密钥和 IV
+AES_CBC aes(key_vec, iv_vec);          // 使用外部密钥和 IV（校验 32B 密钥 + 16B IV）
 std::string hex = aes.encrypt(text);   // 加密，返回 hex 密文
 std::string raw = aes.decrypt(hex);    // 解密 hex 密文，返回原文
 std::string k = aes.get_key();         // 获取密钥（hex）
@@ -45,6 +47,8 @@ std::string v = aes.get_iv();          // 获取 IV（hex）
 
 加密输出为 hex 编码的密文，非原始字节。解密接受 hex 输入，返回原始字符串。
 
+参数化构造函数会校验密钥长度（必须 32 字节）和 IV 长度（必须 16 字节），不匹配时抛出 `std::runtime_error`。
+
 ### Base64 — Base64 编解码
 
 提供实例方法和静态工具方法两种调用方式。
@@ -56,7 +60,7 @@ std::string v = aes.get_iv();          // 获取 IV（hex）
 | `decode_to_bytes(b64)` | 解码为字节向量 |
 | `base64_encode(str)` (static) | 静态编码工具 |
 | `base64_decode_to_string(b64)` (static) | 静态解码工具 |
-| `is_valid_base64(str)` (static) | 验证字符集合法性（不依赖 OpenSSL） |
+| `is_valid_base64(str)` (static) | 验证格式合法性：字符集 + 长度为 4 的倍数 + `=` 填充规则（不依赖 OpenSSL） |
 
 编码不添加换行符（`BIO_FLAGS_BASE64_NO_NL`）。
 
@@ -66,7 +70,7 @@ std::string v = aes.get_iv();          // 获取 IV（hex）
 SHA256 h;
 std::string hex = h.hash("hello");           // 字符串 → hex 哈希
 auto bytes = h.hash_bytes("hello");          // 字符串 → 字节哈希
-bool ok = h.verify("hello", expected_hex);   // 验证
+bool ok = h.verify("hello", expected_hex);   // 验证（常量时间比较，防时序侧信道）
 
 // 静态快捷方式
 std::string h = SHA256::sha256("hello");
@@ -80,7 +84,7 @@ std::string h = SHA256::sha256("hello");
 MyRSA::Generator gen;
 gen.save_pri_key("private.pem", "password");  // PKCS#8 + AES-256-CBC 加密
 gen.save_pub_key("public.pem");               // SubjectPublicKeyInfo
-std::string pem = gen.get_public_key_pem();    // 导出 PEM 字符串
+std::string pem = gen.get_public_key_pem();    // 导出 PEM 字符串（失败时抛出 CryptoExp）
 ```
 
 **Private_Key** — 加载私钥（支持 PKCS#1/PKCS#8，加密或明文）。
@@ -194,6 +198,17 @@ libcrypt/
 - **hex 编码**：`bytes_to_hex` 使用查表法实现，位于 `Crypto_Basic.cpp` 中编译进 `.so`。`SHA256` 不再有私有副本。
 - **`Private_Key` 私有继承**：该设计防止 `Private_Key` 被隐式转换为 `Crypto_Basic*`，是刻意为之的安全措施。
 
+## 变更记录
+
+### v0.0.2 — 安全加固（2026-08-08）
+
+| 文件 | 变更 |
+|------|------|
+| AES_CBC.hpp | 添加 `#pragma once`；`EVP_CIPHER_CTX` 改为 RAII（`EVP_CIPHER_CTX_ptr`），消除异常路径内存泄漏；构造函数校验密钥 32B / IV 16B；参数改为 `const&`；`encrypt`/`decrypt` 参数改为 `const std::string&`；`EVP_EncryptUpdate` 入参 `static_cast<int>` 防 size_t 截断；移除 `print_bytes` 调试方法 |
+| SHA256.hpp | `EVP_MD_CTX` 改为 RAII（`EVP_MD_CTX_ptr_sha`）；`verify()` 改用 `CRYPTO_memcmp` 常量时间比较，防时序侧信道攻击；移除 `print_hash` 调试方法 |
+| Base64.hpp | 添加 `#pragma once`；`BIO*` 改为 RAII（`BIO_ptr_b64`）；`is_valid_base64` 增强校验（长度为 4 的倍数 + `=` 仅末尾且 ≤2 个）；移除 `print_encoded`/`print_decoded` 调试方法 |
+| MyRSA.hpp | `Generator` 构造函数校验密钥非空，失败抛出 `CryptoExp`；`key_to_pem` 失败时抛出异常而非返回空字符串；提取共享 `password_callback` 静态方法，消除两处重复 lambda |
+
 ## 许可证
 
 MIT License

libcrypt/inc/us/AES_CBC.hpp

@@ -1,12 +1,17 @@
+#pragma once
 #include "Crypto_Basic.hpp"
 #include <openssl/evp.h>
 #include <openssl/err.h>
 #include <openssl/rand.h>
-#include <iomanip>
-#include <iostream>
+#include <memory>
 #include <vector>
 #include <stdexcept>
 
+struct EVP_CIPHER_CTX_deleter {
+	void operator()(EVP_CIPHER_CTX* ctx) const { EVP_CIPHER_CTX_free(ctx); }
+};
+using EVP_CIPHER_CTX_ptr = std::unique_ptr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_deleter>;
+
 namespace qing {
 	class AES_CBC: public qing::Crypto_Basic {
 	public:
@@ -14,7 +19,9 @@ namespace qing {
 	AES_CBC() {
 		generate_key_iv(key, iv);
 	}
-	AES_CBC(std::vector<unsigned char> &key, std::vector<unsigned char> &iv) {
+	AES_CBC(const std::vector<unsigned char>& key, const std::vector<unsigned char>& iv) {
+		CRYPTO_CHECK(key.size() == 32, "AES-256 需要 32 字节密钥");
+		CRYPTO_CHECK(iv.size() == 16, "AES-CBC 需要 16 字节 IV");
 		this->key = key;
 		this->iv = iv;
 	}
@@ -25,31 +32,17 @@ namespace qing {
 		return bytes_to_hex(iv);
 	}
 	
-	std::string encrypt(std::string original_text) {
+	std::string encrypt(const std::string& original_text) {
 		std::vector<unsigned char> plaintext(original_text.begin(), original_text.end());
 		std::vector<unsigned char> ciphertext = aes_encrypt(plaintext, key, iv);
-
-		// hex-bytes转换测试
-		/*std::string hex = bytes_to_hex(ciphertext);
-		std::vector<unsigned char> cipher2 = hex_to_bytes(hex);
-		print_bytes(ciphertext);
-		print_bytes(cipher2);*/
-		
 		return bytes_to_hex(ciphertext);
 	}
 
-	std::string decrypt(std::string cipher_hex) {
+	std::string decrypt(const std::string& cipher_hex) {
 		std::vector<unsigned char> ciphertext = hex_to_bytes(cipher_hex);
 		std::vector<unsigned char> decrypted = aes_decrypt(ciphertext, key, iv);
 		return std::string(decrypted.begin(), decrypted.end());
 	}
-
-	static void print_bytes(std::vector<unsigned char>& bytes) {
-		for (unsigned char byte : bytes) {
-			std::cerr << std::setw(2) << static_cast<int>(byte);
-		}
-		std::cerr << std::endl;
-	}
 	
 	private:
 	std::vector<unsigned char> key;
@@ -71,48 +64,44 @@ namespace qing {
 	static std::vector<unsigned char> aes_encrypt(const std::vector<unsigned char>& plaintext,
 			const std::vector<unsigned char>& key,
 			const std::vector<unsigned char>& iv) {
-		// 创建上下文
-		EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
+		// 创建上下文（RAII 自动释放）
+		EVP_CIPHER_CTX_ptr ctx(EVP_CIPHER_CTX_new());
 		CRYPTO_CHECK(ctx != nullptr, "无法创建加密上下文");
 
 		// 初始化加密操作
-		CRYPTO_CHECK(EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), nullptr,
-					key.data(), iv.data()) , "加密初始化失败");
+		CRYPTO_CHECK(EVP_EncryptInit_ex(ctx.get(), EVP_aes_256_cbc(), nullptr,
+					key.data(), iv.data()) == 1, "加密初始化失败");
 
 		// 输出缓冲区 （密文可能比明文长一个块）
-		std::vector<unsigned char> ciphertext(plaintext.size() + EVP_CIPHER_CTX_block_size(ctx));
+		std::vector<unsigned char> ciphertext(plaintext.size() + EVP_CIPHER_CTX_block_size(ctx.get()));
 		int len = 0;
 		int ciphertext_len = 0;
 
 		// 提供明文数据
-		CRYPTO_CHECK(EVP_EncryptUpdate(ctx, ciphertext.data(), &len,
-					plaintext.data(), plaintext.size()) == 1, "加载更新失败");
+		CRYPTO_CHECK(EVP_EncryptUpdate(ctx.get(), ciphertext.data(), &len,
+					plaintext.data(), static_cast<int>(plaintext.size())) == 1, "加密更新失败");
 		ciphertext_len = len;
 
 		// 完成加密（处理填充）
-		CRYPTO_CHECK(EVP_EncryptFinal_ex(ctx, ciphertext.data() + len, &len) == 1, "加密结束失败");
+		CRYPTO_CHECK(EVP_EncryptFinal_ex(ctx.get(), ciphertext.data() + len, &len) == 1, "加密结束失败");
 		ciphertext_len += len;
 
 		// 调整到实际密文长度
 		ciphertext.resize(ciphertext_len);
 
-		// 处理上下文
-		EVP_CIPHER_CTX_free(ctx);
-
 		return ciphertext;
-
 	}
 
-	// AES-256-CBC
+	// AES-256-CBC 解密
 	static std::vector<unsigned char> aes_decrypt(const std::vector<unsigned char>& ciphertext,
 			const std::vector<unsigned char>& key,
 			const std::vector<unsigned char>& iv) {
-		// 创建上下文
-		EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
+		// 创建上下文（RAII 自动释放）
+		EVP_CIPHER_CTX_ptr ctx(EVP_CIPHER_CTX_new());
 		CRYPTO_CHECK(ctx != nullptr, "无法创建解密上下文");
 
 		// 初始化解密操作
-		CRYPTO_CHECK(EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), nullptr,
+		CRYPTO_CHECK(EVP_DecryptInit_ex(ctx.get(), EVP_aes_256_cbc(), nullptr,
 					key.data(), iv.data()) == 1, "解密初始化失败");
 
 		// 输出缓冲区（明文可能比密文短，但最大为密文长度）
@@ -121,20 +110,17 @@ namespace qing {
 		int plaintext_len = 0;
 
 		// 提供密文数据
-		CRYPTO_CHECK(EVP_DecryptUpdate(ctx, plaintext.data(), &len, 
-					ciphertext.data(), ciphertext.size()) == 1, "解密更新失败");
+		CRYPTO_CHECK(EVP_DecryptUpdate(ctx.get(), plaintext.data(), &len, 
+					ciphertext.data(), static_cast<int>(ciphertext.size())) == 1, "解密更新失败");
 		plaintext_len = len;
 
 		// 完成解密（处理填充）
-		CRYPTO_CHECK(EVP_DecryptFinal_ex(ctx, plaintext.data() + len, &len) == 1, "解密结束失败");
+		CRYPTO_CHECK(EVP_DecryptFinal_ex(ctx.get(), plaintext.data() + len, &len) == 1, "解密结束失败");
 		plaintext_len += len;
 
 		// 调整到实际明文长度
 		plaintext.resize(plaintext_len);
 
-		// 清理上下文
-		EVP_CIPHER_CTX_free(ctx);
-
 		return plaintext;
 	}
 	};

libcrypt/inc/us/Base64.hpp

@@ -1,14 +1,18 @@
+#pragma once
 #include <openssl/evp.h>
 #include <openssl/bio.h>
 #include <openssl/buffer.h>
-#include <iostream>
+#include <memory>
 #include <vector>
 #include <string>
 #include <stdexcept>
-#include <iomanip>
-#include <sstream>
 #include "Crypto_Basic.hpp"
 
+struct BIO_deleter_b64 {
+	void operator()(BIO* bio) const { BIO_free_all(bio); }
+};
+using BIO_ptr_b64 = std::unique_ptr<BIO, BIO_deleter_b64>;
+
 namespace qing {
 	class Base64 : public qing::Crypto_Basic {
 	public:
@@ -44,36 +48,33 @@ namespace qing {
 		
 		/* 静态方法：直接编码字节向量（工具函数） */
 		static std::string base64_encode(const std::vector<unsigned char>& input_bytes) {
-			// 创建BIO链：内存BIO -> Base64 BIO
-			BIO* bio = BIO_new(BIO_s_mem());
+			// 创建BIO链：内存BIO -> Base64 BIO（RAII 自动释放）
+			BIO_ptr_b64 bio(BIO_new(BIO_s_mem()));
 			CRYPTO_CHECK(bio != nullptr, "无法创建内存BIO");
 			
 			BIO* b64 = BIO_new(BIO_f_base64());
 			CRYPTO_CHECK(b64 != nullptr, "无法创建Base64 BIO");
 			
 			// 将Base64 BIO连接到内存BIO
-			bio = BIO_push(b64, bio);
+			bio.reset(BIO_push(b64, bio.release()));
 			
 			// 设置不添加换行符（默认会添加换行）
-			BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
+			BIO_set_flags(bio.get(), BIO_FLAGS_BASE64_NO_NL);
 			
 			// 写入数据
-			int written = BIO_write(bio, input_bytes.data(), input_bytes.size());
-			CRYPTO_CHECK(written == (int)input_bytes.size(), "Base64编码写入失败");
+			int written = BIO_write(bio.get(), input_bytes.data(), static_cast<int>(input_bytes.size()));
+			CRYPTO_CHECK(written == static_cast<int>(input_bytes.size()), "Base64编码写入失败");
 			
 			// 刷新缓冲区
-			CRYPTO_CHECK(BIO_flush(bio) == 1, "Base64编码刷新失败");
+			CRYPTO_CHECK(BIO_flush(bio.get()) == 1, "Base64编码刷新失败");
 			
 			// 读取编码结果
 			BUF_MEM* bptr;
-			BIO_get_mem_ptr(bio, &bptr);
+			BIO_get_mem_ptr(bio.get(), &bptr);
 			
 			// 复制结果到字符串（不包括空终止符）
 			std::string result(bptr->data, bptr->length);
 			
-			// 清理BIO
-			BIO_free_all(bio);
-			
 			return result;
 		}
 		
@@ -85,18 +86,18 @@ namespace qing {
 		
 		/* 静态方法：直接解码为字节向量（工具函数） */
 		static std::vector<unsigned char> base64_decode_to_bytes(const std::string& base64_text) {
-			// 创建BIO链：Base64 BIO -> 内存BIO
-			BIO* bio = BIO_new_mem_buf(base64_text.c_str(), -1);
+			// 创建BIO链：Base64 BIO -> 内存BIO（RAII 自动释放）
+			BIO_ptr_b64 bio(BIO_new_mem_buf(base64_text.c_str(), -1));
 			CRYPTO_CHECK(bio != nullptr, "无法创建内存BIO");
 			
 			BIO* b64 = BIO_new(BIO_f_base64());
 			CRYPTO_CHECK(b64 != nullptr, "无法创建Base64 BIO");
 			
 			// 将Base64 BIO连接到内存BIO
-			bio = BIO_push(b64, bio);
+			bio.reset(BIO_push(b64, bio.release()));
 			
 			// 设置不添加换行符（解码时也要匹配）
-			BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
+			BIO_set_flags(bio.get(), BIO_FLAGS_BASE64_NO_NL);
 			
 			// 准备接收缓冲区
 			std::vector<unsigned char> result;
@@ -104,47 +105,38 @@ namespace qing {
 			int bytes_read;
 			
 			// 循环读取解码数据
-			while ((bytes_read = BIO_read(bio, buffer, sizeof(buffer))) > 0) {
+			while ((bytes_read = BIO_read(bio.get(), buffer, sizeof(buffer))) > 0) {
 				result.insert(result.end(), buffer, buffer + bytes_read);
 			}
 			
 			// 检查是否解码成功（BIO_read返回0表示结束，负值表示错误）
 			CRYPTO_CHECK(bytes_read >= 0, "Base64解码失败");
 			
-			// 清理BIO
-			BIO_free_all(bio);
-			
 			return result;
 		}
 		
 		/* 验证Base64格式是否有效 */
 		static bool is_valid_base64(const std::string& base64_text) {
-			// 检查是否只包含Base64字符（A-Z, a-z, 0-9, +, /, =）
 			if (base64_text.empty()) return false;
+			// 长度必须是4的倍数
+			if (base64_text.size() % 4 != 0) return false;
 			
-			for (char c : base64_text) {
-				if (!((c >= 'A' && c <= 'Z') ||
-				      (c >= 'a' && c <= 'z') ||
-				      (c >= '0' && c <= '9') ||
-				      c == '+' || c == '/' || c == '=')) {
+			size_t padding = 0;
+			for (size_t i = 0; i < base64_text.size(); ++i) {
+				char c = base64_text[i];
+				if (c == '=') {
+					padding++;
+					// '=' 只能出现在末尾且不超过2个
+					if (padding > 2 || i < base64_text.size() - padding) return false;
+				} else if (!((c >= 'A' && c <= 'Z') ||
+				             (c >= 'a' && c <= 'z') ||
+				             (c >= '0' && c <= '9') ||
+				             c == '+' || c == '/')) {
 					return false;
 				}
 			}
 			return true;
 		}
-		
-		/* 打印编码结果（调试用） */
-		static void print_encoded(const std::string& encoded_text) {
-			std::cerr << "Base64 Encoded: " << encoded_text << std::endl;
-		}
-		
-		/* 打印解码结果（调试用） */
-		static void print_decoded(const std::vector<unsigned char>& decoded_bytes) {
-			std::cerr << "Decoded bytes: ";
-			for (unsigned char byte : decoded_bytes) {
-				std::cerr << std::setw(2) << static_cast<int>(byte);
-			}
-			std::cerr << std::endl;
-		}
+
 	};
 }

libcrypt/inc/us/MyRSA.hpp

@@ -51,6 +51,7 @@ namespace qing {
         public:
             Generator() {
                 key = generate_rsa_key();
+                if (!key) throw Crypto_Basic::CryptoExp("RSA 密钥对生成失败");
             }
 
             // 保存私钥为 PKCS#8 格式（AES-256-CBC 加密），支持密码保护
@@ -153,7 +154,7 @@ namespace qing {
                 BIO_ptr bio(BIO_new(BIO_s_mem()));
                 if (!bio) {
                     HANDLE_SSL_ERROR();
-                    return "";
+                    throw Crypto_Basic::CryptoExp("导出 PEM 时无法创建 BIO");
                 }
 
                 int ret;
@@ -169,7 +170,7 @@ namespace qing {
 
                 if (ret != 1) {
                     HANDLE_SSL_ERROR();
-                    return "";
+                    throw Crypto_Basic::CryptoExp("导出 PEM 失败");
                 }
 
                 char* data;
@@ -246,18 +247,7 @@ namespace qing {
                     return nullptr;
                 }
 
-                pem_password_cb* cb = nullptr;
-                if (password) {
-                    cb = [](char* buf, int size, int rwflag, void* u) -> int {
-                        if (!u) return 0;
-                        const char* pass = (const char*)u;
-                        int len = strlen(pass);
-                        if (len > size) len = size;
-                        memcpy(buf, pass, len);
-                        return len;
-                    };
-                }
-
+                pem_password_cb* cb = password ? &password_callback : nullptr;
                 EVP_PKEY* pkey = PEM_read_bio_PrivateKey(bio.get(), nullptr, cb, (void*)password);
                 if (!pkey) {
                     HANDLE_SSL_ERROR();
@@ -274,18 +264,7 @@ namespace qing {
                     return nullptr;
                 }
 
-                pem_password_cb* cb = nullptr;
-                if (password) {
-                    cb = [](char* buf, int size, int rwflag, void* u) -> int {
-                        if (!u) return 0;
-                        const char* pass = (const char*)u;
-                        int len = strlen(pass);
-                        if (len > size) len = size;
-                        memcpy(buf, pass, len);
-                        return len;
-                    };
-                }
-
+                pem_password_cb* cb = password ? &password_callback : nullptr;
                 EVP_PKEY* pkey = PEM_read_bio_PrivateKey(bio.get(), nullptr, cb, (void*)password);
                 if (!pkey) {
                     HANDLE_SSL_ERROR();
@@ -294,6 +273,16 @@ namespace qing {
                 return EVP_PKEY_ptr(pkey);
             }
 
+            // 密码回调（共享，消除重复 lambda）
+            static int password_callback(char* buf, int size, int rwflag, void* u) {
+                if (!u) return 0;
+                const char* pass = static_cast<const char*>(u);
+                int len = static_cast<int>(strlen(pass));
+                if (len > size) len = size;
+                memcpy(buf, pass, len);
+                return len;
+            }
+
             // RSA 解密（OAEP）
             static std::vector<unsigned char> rsa_decrypt(EVP_PKEY* private_key,
                                                            const std::vector<unsigned char>& ciphertext) {

libcrypt/inc/us/SHA256.hpp

@@ -1,12 +1,18 @@
 #pragma once
 #include <openssl/evp.h>
 #include <openssl/err.h>
-#include <iostream>
+#include <openssl/crypto.h>
+#include <memory>
 #include <vector>
 #include <string>
 #include <stdexcept>
 #include "Crypto_Basic.hpp"
 
+struct EVP_MD_CTX_deleter_sha {
+	void operator()(EVP_MD_CTX* ctx) const { EVP_MD_CTX_free(ctx); }
+};
+using EVP_MD_CTX_ptr_sha = std::unique_ptr<EVP_MD_CTX, EVP_MD_CTX_deleter_sha>;
+
 namespace qing {
 
 	class SHA256: public qing::Crypto_Basic {
@@ -40,14 +46,18 @@ namespace qing {
 
 		/* 验证数据是否与给定的哈希值匹配 */
 		bool verify(const std::string& input_text, const std::string& expected_hash_hex) {
-			std::string computed_hash = hash(input_text);
-			return computed_hash == expected_hash_hex;
+			std::vector<unsigned char> computed = hash_bytes(input_text);
+			std::vector<unsigned char> expected = hex_to_bytes(expected_hash_hex);
+			if (computed.size() != expected.size()) return false;
+			return CRYPTO_memcmp(computed.data(), expected.data(), computed.size()) == 0;
 		}
 
 		/* 验证数据是否与给定的哈希值匹配（字节向量版本） */
 		bool verify(const std::vector<unsigned char>& input_bytes, const std::string& expected_hash_hex) {
-			std::string computed_hash = hash(input_bytes);
-			return computed_hash == expected_hash_hex;
+			std::vector<unsigned char> computed = sha256_hash(input_bytes);
+			std::vector<unsigned char> expected = hex_to_bytes(expected_hash_hex);
+			if (computed.size() != expected.size()) return false;
+			return CRYPTO_memcmp(computed.data(), expected.data(), computed.size()) == 0;
 		}
 
 		/* 静态方法：直接计算SHA-256哈希（工具函数） */
@@ -62,39 +72,31 @@ namespace qing {
 			return hasher.hash_bytes(input_text);
 		}
 
-		/* 打印哈希值（调试用） */
-		static void print_hash(const std::vector<unsigned char>& hash_bytes) {
-			std::string hex = bytes_to_hex(hash_bytes);
-			std::cerr << hex << std::endl;
-		}
 
 	private:
 		/* SHA-256哈希核心实现 */
 		static std::vector<unsigned char> sha256_hash(const std::vector<unsigned char>& input) {
-			// 创建EVP上下文
-			EVP_MD_CTX* ctx = EVP_MD_CTX_new();
+			// 创建EVP上下文（RAII 自动释放）
+			EVP_MD_CTX_ptr_sha ctx(EVP_MD_CTX_new());
 			CRYPTO_CHECK(ctx != nullptr, "无法创建哈希上下文");
 
 			// 初始化SHA-256操作
-			CRYPTO_CHECK(EVP_DigestInit_ex(ctx, EVP_sha256(), nullptr) == 1,
+			CRYPTO_CHECK(EVP_DigestInit_ex(ctx.get(), EVP_sha256(), nullptr) == 1,
 						"SHA-256初始化失败");
 
 			// 提供输入数据
-			CRYPTO_CHECK(EVP_DigestUpdate(ctx, input.data(), input.size()) == 1,
+			CRYPTO_CHECK(EVP_DigestUpdate(ctx.get(), input.data(), input.size()) == 1,
 						"SHA-256更新失败");
 
 			// 获取哈希结果
-			std::vector<unsigned char> digest(EVP_MD_CTX_size(ctx)); // SHA-256输出32字节
+			std::vector<unsigned char> digest(EVP_MD_CTX_size(ctx.get())); // SHA-256输出32字节
 			unsigned int digest_len = 0;
-			CRYPTO_CHECK(EVP_DigestFinal_ex(ctx, digest.data(), &digest_len) == 1,
+			CRYPTO_CHECK(EVP_DigestFinal_ex(ctx.get(), digest.data(), &digest_len) == 1,
 						"SHA-256完成失败");
 
 			// 调整到实际长度（应该是32字节）
 			digest.resize(digest_len);
 
-			// 清理上下文
-			EVP_MD_CTX_free(ctx);
-
 			return digest;
 		}
 	};