11种数据库加密原理详解与代码实现
北京理工大学/数达安全联合研究团队
一、加密需求
为保证本文内容连贯、落地性强，本文设定统一加密需求：业务系统需将用户核心敏感数据（手机号、身份证号）存入MySQL数据库，全程防止数据泄露、篡改、勒索窃取，同时区分不同层级访问权限。需通过数据库全链路11个加密点位实现数据加密存储、传输、展示防护，每种技术独立落地该需求，配套原理讲解、场景适配、伪代码示例。
核心约束：敏感字段为 user_phone、user_id_card，数据库表 user_info，需实现数据落盘加密、权限可控、防泄露、防勒索，各加密方式保留自身技术特性差异。
二、业务数据表结构与测试数据
本文所有加密技术落地、伪代码测试均基于统一的user_info 用户信息表，表中包含用户姓名、身份证号、手机号三类业务数据，其中身份证号、手机号为核心敏感加密字段，以下为MySQL表结构及5行可示例测试数据。
|
字段名 |
数据类型 |
是否非空 |
是否主键 |
字段说明 |
|
id |
INT UNSIGNED |
是 |
是 |
用户唯一ID，自增主键 |
|
user_name |
VARCHAR(50) |
是 |
否 |
用户真实姓名（非敏感字段） |
|
user_id_card |
CHAR(18) |
是 |
否 |
用户身份证号（核心敏感加密字段） |
|
user_phone |
CHAR(11) |
是 |
否 |
用户手机号（核心敏感加密字段） |
|
create_time |
DATETIME |
是 |
否 |
数据创建时间，默认当前时间 |
示例测试数据如下：
|
id |
user_name |
user_id_card |
user_phone |
create_time |
|
1 |
张三 |
110101199001011234 |
13800138000 |
2025-01-01 10:00:00 |
|
2 |
李四 |
310101199202021234 |
13900139000 |
2025-01-02 11:00:00 |
|
3 |
王五 |
440101199503031234 |
13700137000 |
2025-01-03 12:00:00 |
|
4 |
赵六 |
510101199804041234 |
13600136000 |
2025-01-04 13:00:00 |
|
5 |
孙七 |
330101200005051234 |
13500135000 |
2025-01-05 14:00:00 |
三、11种数据库加密技术详解
1. 硬盘加密（硬件/磁盘软件加密）
1.1 技术原理
属于数据库最底层物理存储加密，直接对数据库所在物理磁盘、逻辑分区进行全盘加密。加密解密由硬件磁盘固件或系统磁盘加密软件自动完成，对数据库管理系统（MySQL、Oracle等）、业务应用完全透明。数据库读写数据时，无需感知加密逻辑，磁盘层自动完成明文写入加密、密文读取解密。
1.2 安全特性
仅防护磁盘丢失、物理硬盘被盗导致的数据泄露；系统内拥有磁盘访问权限的用户、进程均可直接读取数据库明文文件；无法抵御勒索病毒、无法控制数据库账号、应用账号权限。
1.3 落地实现
将存放MySQL数据文件的磁盘分区全盘加密，业务正常写入用户手机号、身份证号，磁盘层自动加密落盘，数据库无感知。
1.4 伪代码示例
// 硬盘加密（硬件/磁盘软件加密）
// 底层硬件/系统级加密，无业务侵入，C++风格模拟磁盘AES-256加解密逻辑
#include <string>
#include <cstdint>
// 磁盘硬件唯一加密密钥
std::string disk_key = "硬件磁盘唯一加密密钥/系统磁盘密钥";
// 磁盘写入加密：明文落盘自动加密
std::uint8_t* disk_encrypt(const std::uint8_t* raw_data, int data_len, const std::string& key)
{
// 底层磁盘固件自动AES-256-CBC加密
// 此处为标准C++模拟实现
return aes256_cbc_encrypt(raw_data, data_len, (std::uint8_t*)key.c_str());
}
// 磁盘读取解密：读取数据自动解密，上层完全透明
std::uint8_t* disk_decrypt(const std::uint8_t* encrypt_data, int data_len, const std::string& key)
{
return aes256_cbc_decrypt(encrypt_data, data_len, (std::uint8_t*)key.c_str());
}
// 业务层正常写入数据库（零改造）
int main()
{
// 业务插入明文敏感数据
db_execute_sql("INSERT INTO user_info(user_phone,user_id_card) VALUES ('13800138000','110101199001011234')");
// 底层磁盘自动加密落盘，读取时系统自动解密返回明文
return 0;
}
2. 存储加密网关
2.1 技术原理
专为网络存储场景设计（NAS、分布式网络存储），部署在服务器与网络存储设备之间，通过拦截NFS、SMB、iSCSI等存储通讯协议，在数据库文件读写网络传输过程中，自动完成加密、解密操作，对数据库和应用透明。
2.2 安全特性
安全能力与硬盘加密持平，仅防止网络存储设备丢失、传输窃听导致的数据泄露；无法限制系统用户、数据库账号访问权限，无法抵御勒索病毒。
2.3 落地实现
MySQL数据文件存放于NAS网络存储，通过存储加密网关拦截文件读写请求，敏感数据文件上传加密、下载解密。
2.4 伪代码示例
// 存储加密网关 C++ 核心实现
#include <string>
#include <cstdint>
// 存储网关固定加密密钥
std::string gateway_key = "storage_gateway_aes256_key";
// 拦截NAS/网络存储写入请求，文件加密后落盘
std::uint8_t* storage_write_intercept(const std::uint8_t* file_data, int len)
{
// 网关层AES-256加密
return aes256_encrypt(file_data, len, (std::uint8_t*)gateway_key.c_str());
}
// 拦截网络存储读取请求，密文解密后返回数据库
std::uint8_t* storage_read_intercept(const std::uint8_t* encrypt_data, int len)
{
return aes256_decrypt(encrypt_data, len, (std::uint8_t*)gateway_key.c_str());
}
int main()
{
// 数据库原生无改造，正常写入明文数据
db_execute_sql("INSERT INTO user_info(user_phone,user_id_card) VALUES ('13800138000','110101199001011234')");
// 网关拦截写入：加密存入NAS
// 网关拦截读取：解密返回明文给数据库
return 0;
}
3. 文件加密
3.1 技术原理
针对数据库数据文件、索引文件、日志文件单独加密，区别于全盘硬盘加密，精准加密数据库核心文件。通过文件加密软件锁定指定数据库文件，操作系统层级管控文件访问权限，数据库本身无感知，加密解密过程独立于数据库运行。
3.2 安全特性
兼顾防磁盘丢失泄露、防OS非法用户/进程访问数据库文件、可抵御勒索病毒篡改加密数据库文件；无数据库账号权限管控能力，数据库合法账号可正常读取明文数据。
3.3 落地实现
对MySQL的.ibd数据文件、.frm索引文件进行加密锁定，禁止非授权系统进程访问，合法数据库进程可正常读写。
3.4 伪代码示例
// 文件加密 C++ 精准加密实现（仅加密数据库核心文件）
#include <string>
#include <vector>
std::string file_encrypt_key = "db_file_aes256_key";
// 锁定MySQL核心数据文件
std::vector<std::string> target_db_files = {
"/mysql/data/user_info.ibd",
"/mysql/data/user_info.frm"
};
// 数据库文件加密 + 权限锁定
void db_file_encrypt(const std::string& file_path)
{
// 1. 读取明文文件
std::string raw_file = read_file(file_path);
// 2. AES加密覆盖原文件
std::string encrypt_data = aes256_encrypt(raw_file, file_encrypt_key);
write_file(file_path, encrypt_data);
// 3. 系统权限管控：仅mysqld进程可访问
set_file_permission(file_path, "mysqld");
}
// 授权进程读取自动解密
std::string db_file_decrypt(const std::string& file_path)
{
std::string encrypt_data = read_file(file_path);
return aes256_decrypt(encrypt_data, file_encrypt_key);
}
int main()
{
// 业务正常写入数据
db_execute_sql("INSERT INTO user_info(user_phone,user_id_card) VALUES ('13800138000','110101199001011234')");
// 后台线程自动加密数据库文件，拦截非法进程访问
for (auto& path : target_db_files) {
db_file_encrypt(path);
}
return 0;
}
4. OS扩展加密
4.1 技术原理
基于操作系统驱动、HOOK钩子机制，拦截数据库进程的文件读写请求、数据库客户端对数据库的读写请求。在OS层对数据库落地数据自动加密存储，同时根据登录数据库的账号权限判定是否返回解密明文，实现OS+数据库双层权限管控。
4.2 安全特性
可抵御非授权数据库文件读写、勒索病毒；可管控数据库账号访问权限。无法识别、管控上层业务内应用账号。
4.3 落地实现
对MySQL的.ibd数据文件、.frm索引文件进行加密锁定，禁止非授权系统进程访问，合法数据库进程可正常读写。
对MySQL客户端访问进行拦截，禁止非授权数据库用户访问，合法数据库用户可正常读写。
4.4 伪代码示例
// OS扩展加密（文件读写+账号权限管控）C++实现
#include <string>
#include <unordered_map>
std::string os_encrypt_key = "os_hook_db_key";
// 数据库账号权限映射表
std::unordered_map<std::string, bool> db_user_perm = {
{"admin", true},
{"guest", false}
};
// 拦截数据库写入：统一加密落盘
std::string hook_db_write(const std::string& raw_data)
{
return aes256_encrypt(raw_data, os_encrypt_key);
}
// 拦截读取：根据账号权限返回明文/拦截
std::string hook_db_read(const std::string& db_user, const std::string& encrypt_data)
{
if (db_user_perm[db_user]) {
return aes256_decrypt(encrypt_data, os_encrypt_key);
}
return "权限不足，无法读取敏感数据";
}
int main()
{
// 场景1：有权账号读写
db_login("admin", "******");
db_execute_sql("INSERT INTO user_info(user_phone,user_id_card) VALUES ('13800138000','110101199001011234')");
std::string res1 = db_query("SELECT * FROM user_info");
std::cout << hook_db_read("admin", res1) << std::endl; // 明文
// 场景2：无权账号读取被拦截
db_login("guest", "******");
std::string res2 = db_query("SELECT * FROM user_info");
std::cout << hook_db_read("guest", res2) << std::endl; // 权限拦截
return 0;
}
5. 数据库自带加密
5.1 技术原理
数据库原生源码级加密能力（MySQL TDE透明数据加密、Oracle透明加密），数据库内核层面实现数据落盘加密，无需依赖系统、硬件、中间件，数据库自身完成加密解密逻辑，原生支持数据库账号权限管控。
5.2 安全特性
原生管控数据库账号访问权限，兼容性强、稳定性高；无法抵御勒索病毒攻击，病毒可直接加密数据库密文文件，导致数据丢失；难以替换国密算法。
5.3 落地实现
开启MySQL原生TDE加密，对user_info表开启透明加密，数据库内核自动完成敏感字段加密落盘，基于数据库账号控制访问权限。
5.4 伪代码示例
// 数据库原生TDE加密 C++ 模拟实现
#include <string>
// 数据库主密钥
std::string tde_master_key = "mysql_native_tde_key";
// 模拟数据库TDE内核加密开关
void enable_tde_encryption()
{
// 开启内核透明加密插件
db_exec_dsl("ENABLE_TDE_ENCRYPTION;");
db_exec_dsl("SET GLOBAL tde_master_key = ?", tde_master_key);
// 业务表开启加密
db_exec_dsl("ALTER TABLE user_info ENCRYPTION = 'Y';");
}
int main()
{
enable_tde_encryption();
// 业务无感知写入，内核自动加密落盘
db_execute_sql("INSERT INTO user_info(user_phone,user_id_card) VALUES ('13800138000','110101199001011234')");
// 有权限账号查询自动解密返回明文
std::string res = db_query("SELECT user_phone,user_id_card FROM user_info");
std::cout << res << std::endl;
// 无权限账号直接拦截（数据库原生权限控制）
db_switch_user("guest");
std::string deny_res = db_query("SELECT * FROM user_info");
std::cout << deny_res << std::endl; // 拒绝访问
return 0;
}
6. 库内扩展加密
6.1 技术原理
基于数据库原生扩展能力（视图、触发器、存储过程、密文索引）实现字段级透明加密，无需改造外部系统，纯库内逻辑实现：数据插入时通过触发器自动加密，查询时通过视图自动解密，依托扩展索引实现密文检索。
6.2 安全特性
精准管控数据库用户对加密字段的访问权限；仅Oracle等少数数据库完善支持密文索引，MySQL支持较弱；加密解密依赖库内组件，且密文索引性能远低于原生索引，对数据库性能损耗较大。
6.3 落地实现
创建触发器实现手机号、身份证号字段入库自动加密。创建解密视图实现查询透明解密，搭建密文索引支持模糊检索。
6.4 伪代码示例
// 库内扩展字段加密 C++ 模拟触发器+视图逻辑
#include <string>
std::string db_ext_key = "oracle_field_aes_key";
// 模拟入库触发器：字段自动加密
void trigger_field_encrypt(std::string& phone, std::string& id_card)
{
phone = aes256_encrypt(phone, db_ext_key);
id_card = aes256_encrypt(id_card, db_ext_key);
}
// 模拟查询视图：字段自动解密
void view_field_decrypt(std::string& phone, std::string& id_card)
{
phone = aes256_decrypt(phone, db_ext_key);
id_card = aes256_decrypt(id_card, db_ext_key);
}
int main()
{
// 1. 模拟插入触发加密
std::string phone = "13800138000";
std::string id_card = "110101199001011234";
trigger_field_encrypt(phone, id_card);
db_execute_sql("INSERT INTO user_info(user_phone,user_id_card) VALUES (?,?)", phone, id_card);
//更新密文索引
update_cipher_index();
// 2. 模拟视图查询解密
auto row = db_query_row("SELECT user_phone,user_id_card FROM user_info");
view_field_decrypt(row.phone, row.id_card);
std::cout << row.phone << " " << row.id_card << std::endl;
}
7. 数据库加密网关
7.1 技术原理
部署在应用与数据库之间的独立网关，拦截所有SQL访问请求（增删改查），在网关层完成敏感字段的加密、解密、权限校验，对上层应用、底层数据库实现透明加密。
7.2 安全特性
可精细化管控数据库账号访问权限；不支持库内触发器、视图、存储过程等原生功能的透明适配，网关转发会产生性能损耗，整体性能偏低。
7.3 落地实现
数据库网关拦截应用SQL写入请求，识别手机号、身份证号字段并加密后入库；拦截查询请求，解密后返回明文数据；基于数据库账号管控访问权限。
7.4 伪代码示例
// 数据库加密网关 C++ 拦截器核心逻辑
#include <string>
#include <vector>
std::string db_gateway_key = "db_gateway_aes256_key";
std::vector<std::string> sensitive_fields = {"user_phone", "user_id_card"};
// 网关统一SQL拦截入口
std::string gateway_sql_intercept(const std::string& sql, const std::string& db_user)
{
// 1. 校验数据库账号权限
if (!check_db_user_perm(db_user)) {
return "数据库账号权限不足";
}
// 2. 写入SQL：加密敏感字段
if (sql.substr(0, 6) == "INSERT") {
auto params = parse_sql_params(sql, sensitive_fields);
for (auto& p : params) {
p.value = aes256_encrypt(p.value, db_gateway_key);
}
std::string new_sql = replace_sql_params(sql, params);
return db_execute_sql(new_sql);
}
// 3. 查询SQL：解密返回明文
if (sql.substr(0, 6) == "SELECT") {
auto cipher_result = db_query(sql);
auto plain_result = decrypt_result_fields(cipher_result, sensitive_fields, db_gateway_key);
return plain_result;
}
return db_execute_sql(sql);
}
int main()
{
// 网关透明代理读写
gateway_sql_intercept("INSERT INTO user_info(user_phone,user_id_card) VALUES ('13800138000','110101199001011234')", "admin");
std::string res = gateway_sql_intercept("SELECT * FROM user_info", "admin");
std::cout << res << std::endl;
return 0;
}
8. 数据库连接驱动加密
8.1 技术原理
基于数据库访问驱动扩展（JDBC、AOP、MyBatis切面）实现加密，无需部署独立网关，通过改写数据库连接驱动、新增切面拦截逻辑，在应用与数据库的连接层完成数据加密解密，核心特性与数据库加密网关一致。
8.2 安全特性
权限管控能力与加密网关一致，轻量化无独立网关；不支持库内原生组件适配，存在较大性能损耗，改造量小于应用全量加密。但是会导致数据库原生索引、函数、存储过程等机制失效。
8.3 落地实现（统一需求）
扩展JDBC驱动，拦截Java应用的数据库读写请求，自动对手机号、身份证号加密入库、解密返回。
8.4 伪代码示例
// JDBC驱动扩展加密 C++ 切面实现
#include <string>
#include <map>
std::string jdbc_encrypt_key = "jdbc_driver_encrypt_key";
// 前置切面：拦截写入参数加密
void jdbc_insert_aspect(std::map<std::string, std::string>& params)
{
if (params.count("user_phone")) {
params["user_phone"] = aes256_encrypt(params["user_phone"], jdbc_encrypt_key);
}
if (params.count("user_id_card")) {
params["user_id_card"] = aes256_encrypt(params["user_id_card"], jdbc_encrypt_key);
}
}
// 后置切面：拦截查询结果解密
void jdbc_query_aspect(std::vector<std::map<std::string, std::string>>& result_list)
{
for (auto& row : result_list) {
if (row.count("user_phone")) {
row["user_phone"] = aes256_decrypt(row["user_phone"], jdbc_encrypt_key);
}
if (row.count("user_id_card")) {
row["user_id_card"] = aes256_decrypt(row["user_id_card"], jdbc_encrypt_key);
}
}
}
int main()
{
// 模拟业务JDBC写入
std::map<std::string, std::string> params;
params["user_phone"] = "13800138000";
params["user_id_card"] = "110101199001011234";
jdbc_insert_aspect(params);
jdbc_execute("INSERT INTO user_info(user_phone,user_id_card) VALUES (?,?)", params);
// 模拟业务JDBC查询
auto res_list = jdbc_query("SELECT * FROM user_info");
jdbc_query_aspect(res_list);
return 0;
}
9. 应用加密
9.1 技术原理
业务应用层原生加密，无任何底层、中间件依赖，在业务代码中主动调用加密算法、密钥管理工具，实现敏感数据加密后入库、查询后解密，同时自主实现密文检索、应用账号权限管控。
9.2 安全特性
可精准管控应用层账号访问权限，安全粒度细；需要大幅改造业务代码，开发、维护成本极高，属于高安全高改造成本方案；数据库原生索引失效，性能成忧；采用确定性加密会降低安全性。
9.3 落地实现
业务系统代码中手动加密手机号、身份证号，加密密文存入数据库，查询时根据应用用户权限解密数据。
9.4 伪代码示例
// 应用层加密 C++ 完整权限+加解密逻辑
#include <string>
#include <unordered_map>
std::string app_encrypt_key = "business_app_aes_key";
std::unordered_map<std::string, bool> app_user_perm = {
{"super_admin", true},
{"user", false}
};
// 业务写入：权限校验+主动加密入库
int save_user_data(const std::string& phone, const std::string& id_card, const std::string& app_user)
{
if (!app_user_perm[app_user]) {
std::cout << "应用账号无操作权限" << std::endl;
return -1;
}
// 应用层主动加密
std::string enc_phone = aes256_encrypt(phone, app_encrypt_key);
std::string enc_id = aes256_encrypt(id_card, app_encrypt_key);
// 密文入库
db_execute_sql("INSERT INTO user_info(user_phone,user_id_card) VALUES (?,?)", enc_phone, enc_id);
return 0;
}
// 业务查询：权限校验+主动解密
std::map<std::string, std::string> get_user_data(const std::string& app_user)
{
auto cipher_data = db_query_row("SELECT * FROM user_info");
if (!app_user_perm[app_user]) {
return {{"msg", "应用账号无查看权限"}};
}
// 解密返回明文
cipher_data["user_phone"] = aes256_decrypt(cipher_data["user_phone"], app_encrypt_key);
cipher_data["user_id_card"] = aes256_decrypt(cipher_data["user_id_card"], app_encrypt_key);
return cipher_data;
}
int main()
{
save_user_data("13800138000", "110101199001011234", "super_admin");
auto admin_res = get_user_data("super_admin");
auto user_res = get_user_data("user");
std::cout << "管理员查看：" << admin_res["user_phone"] << std::endl;
std::cout << "普通用户查看：" << user_res["msg"] << std::endl;
return 0;
}
10. 应用代理加密
10.1 技术原理
也称作CASB实现方式，在业务应用前端部署独立代理程序，所有用户请求、数据流转均经过代理层，在数据进入应用系统前完成加密，数据返回前端前完成解密。应用、数据库全程仅接触密文，无任何明文数据留存。
10.2 安全特性
安全性极高，真实明文对应用、数据库完全透明；无法支持加密数据检索，业务适配复杂度极高，透明性差、落地受限多。
10.3 落地实现
用户提交的手机号、身份证号先经过应用代理加密，密文传入应用、存入数据库；前端查询数据时，代理解密后返回明文，应用全程无明文。
10.4 伪代码示例
// 应用代理加密 C++ 拦截逻辑
#include <string>
#include <map>
std::string app_proxy_key = "app_proxy_secure_key";
// 前置拦截：用户明文数据 -> 代理加密 -> 应用/数据库密文
std::map<std::string, std::string> proxy_before_save(const std::map<std::string, std::string>& submit_data)
{
std::map<std::string, std::string> cipher_data = submit_data;
cipher_data["user_phone"] = aes256_encrypt(cipher_data["user_phone"], app_proxy_key);
cipher_data["user_id_card"] = aes256_encrypt(cipher_data["user_id_card"], app_proxy_key);
// 密文传入应用、存入数据库
app_receive_data(cipher_data);
db_insert_map(cipher_data);
return cipher_data;
}
// 后置拦截：数据库密文 -> 代理解密 -> 前端明文展示
std::map<std::string, std::string> proxy_after_query(const std::map<std::string, std::string>& cipher_data)
{
std::map<std::string, std::string> plain_data;
plain_data["user_phone"] = aes256_decrypt(cipher_data["user_phone"], app_proxy_key);
plain_data["user_id_card"] = aes256_decrypt(cipher_data["user_id_card"], app_proxy_key);
return plain_data;
}
int main()
{
// 用户前端明文提交
std::map<std::string, std::string> user_input = {
{"user_phone", "13800138000"},
{"user_id_card", "110101199001011234"}
};
// 代理加密流转
auto cipher_res = proxy_before_save(user_input);
std::cout << "应用接收密文：" << cipher_res["user_phone"] << std::endl;
// 代理解密展示
auto plain_res = proxy_after_query(cipher_res);
std::cout << "前端展示明文：" << plain_res["user_phone"] << std::endl;
return 0;
}
11. 终端加密
11.1 技术原理
全链路最前端加密方案，依托终端安全控件（浏览器插件、客户端控件、APP安全SDK），用户在终端输入数据的瞬间完成加密，加密密文传输至应用、数据库，全程传输、存储无明文；数据展示时，仅终端控件可解密展示明文。
11.2 安全特性
理论最高安全性，明文仅存在于用户终端输入瞬间；完全不透明，业务适配难度、开发难度最大，全链路无任何明文泄露风险。
11.3 落地实现
用户在客户端输入手机号、身份证号，终端SDK即时加密，密文传输至应用和数据库，仅终端控件可解密展示，链路全程密文流转。
11.4 伪代码示例
// 终端加密 C++ SDK 全链路实现
#include <string>
#include <map>
// 终端独立安全密钥（仅终端SDK持有）
std::string terminal_secure_key = "user_terminal_sdk_key";
// 终端输入瞬间加密：明文不落地、不传输
std::map<std::string, std::string> terminal_input_encrypt(const std::string& phone, const std::string& id_card)
{
std::map<std::string, std::string> cipher_data;
cipher_data["user_phone"] = aes256_encrypt(phone, terminal_secure_key);
cipher_data["user_id_card"] = aes256_encrypt(id_card, terminal_secure_key);
return cipher_data;
}
// 终端本地解密：仅终端可展示明文
std::map<std::string, std::string> terminal_show_decrypt(const std::map<std::string, std::string>& cipher_data)
{
std::map<std::string, std::string> plain_data;
plain_data["user_phone"] = aes256_decrypt(cipher_data["user_phone"], terminal_secure_key);
plain_data["user_id_card"] = aes256_decrypt(cipher_data["user_id_card"], terminal_secure_key);
return plain_data;
}
int main()
{
// 1. 终端输入即时加密
auto cipher_data = terminal_input_encrypt("13800138000", "110101199001011234");
// 2. 全链路密文传输、存储
app_receive_data(cipher_data);
db_insert_map(cipher_data);
// 3. 服务端/数据库全程无明文
std::cout << "数据库存储密文：" << cipher_data["user_phone"] << std::endl;
// 4. 仅终端解密展示明文
auto plain_data = terminal_show_decrypt(cipher_data);
std::cout << "终端展示明文：" << plain_data["user_phone"] << std::endl;
return 0;
}
四、11种加密技术核心能力对比总结
|
加密方式 |
防磁盘泄露 |
防勒索病毒 |
数据库账号管控 |
应用账号管控 |
密文检索支持 |
改造难度 |
安全性 |
|
硬盘加密 |
✅ |
❌ |
❌ |
❌ |
✅ |
极低 |
低 |
|
存储加密网关 |
✅ |
❌ |
❌ |
❌ |
✅ |
极低 |
低 |
|
文件加密 |
✅ |
✅ |
❌ |
❌ |
✅ |
低 |
中低 |
|
OS扩展加密 |
✅ |
✅ |
✅ |
❌ |
✅ |
很低 |
很高 |
|
数据库自带加密 |
✅ |
❌ |
✅ |
❌ |
✅ |
极低 |
高 |
|
库内扩展字段加密 |
✅ |
❌ |
✅ |
❌ |
差 |
中 |
高 |
|
数据库加密网关 |
✅ |
❌ |
✅ |
❌ |
差 |
中高 |
高 |
|
连接驱动加密 |
✅ |
❌ |
✅ |
❌ |
差 |
中高 |
高 |
|
应用加密 |
✅ |
❌ |
❌ |
✅ |
差 |
极高 |
高 |
|
应用代理加密 |
✅ |
❌ |
❌ |
✅ |
❌ |
极高 |
极高 |
|
终端加密 |
✅ |
❌ |
❌ |
✅ |
❌ |
最高 |
最高 |
五、落地选型科普建议
1. 轻量化低安全需求：优先选择硬盘加密、数据库原生加密，无代码改造、快速落地，满足基础防泄露需求；
2. 小型系统，无性能要求：选择库内扩展字段加密、数据库加密网关、连接驱动加密，安全性有保障；
3. 大型系统，兼顾合规和性能：首选OS扩展加密，平衡安全与改造成本；
4. 精细化业务权限管控需求，无性能担忧：选择应用代理加密，支持应用账号级别权限控制；
5. 极致安全、零明文留存需求：选择应用代理加密、终端加密，以牺牲易用性与性能为代价。
上述11个点是理论上存在的11个改造点，但是并不是都能够形成商品化的产品。业界已形成商业化产品的技术包括：库内扩展字段加密、数据库加密网关及连接驱动加密、OS扩展加密，它们分别被称为第一代、第二代和第三代产品。在国外，以IBM为代表的企业也在主推第三代技术。
免费领 150 小时云算力，进群参与显卡、AI PC 幸运抽奖
更多推荐
7
0- 0
已为社区贡献1条内容
所有评论(0)