加密 on Kernel Notes

海量 1 用例 oracle加密函数

Tue, 25 Feb 2025 15:31:00 +0800

CREATE SCHEMA pgcrypto_2_text;
SET search_path TO pgcrypto_2_text;

/* ------------------------------------------------------------------------------------------------
 * part 0: create some utils functions
 * ------------------------------------------------------------------------------------------------
 */
CREATE FUNCTION strtoraw(string VARCHAR2) RETURN RAW IS
BEGIN
RETURN utl_raw.cast_to_raw(string);
END;
/

CREATE FUNCTION rawtostr(rawdata RAW) RETURN VARCHAR2 IS
BEGIN
RETURN utl_raw.cast_to_varchar2(rawdata);
END;
/

-- get data type name
CREATE OR REPLACE FUNCTION oidgettype(typeoid OID)
RETURNS TEXT AS $$
BEGIN
 RETURN (SELECT typname FROM pg_type WHERE oid = typeoid);
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION oidgettype(typeoids OIDVECTOR)
RETURNS TEXT[] AS $$
DECLARE
 result TEXT[] := '{}';
 typoid OID;
 typename TEXT;
BEGIN
 FOREACH typoid IN ARRAY typeoids LOOP
 SELECT typname INTO typename
 FROM pg_type
 WHERE oid = typoid;
 result := array_append(result, COALESCE(typename, 'Unknown OID'));
 END LOOP;
 RETURN result;
END;
$$ LANGUAGE plpgsql;

-- find all functions from dbms_obfuscation_toolkit
CREATE VIEW allfuncs AS
SELECT proname name,pronargs args,oidgettype(prorettype) output,oidgettype(proargtypes) input
FROM pg_proc
WHERE pronamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'dbms_obfuscation_toolkit') ORDER BY 1,3,2;

/* ------------------------------------------------------------------------------------------------
 * part 1: install pgcrypt with different versions
 * ------------------------------------------------------------------------------------------------
 */
-- available version
SELECT * FROM pg_available_extension_versions WHERE name = 'pgcrypto';

-- 2.0 (default version)
CREATE EXTENSION pgcrypto;
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
SELECT * FROM allfuncs;
DROP EXTENSION pgcrypto;

-- 1.2 (old version)
CREATE EXTENSION pgcrypto WITH VERSION '1.2';
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
SELECT * FROM allfuncs;
DROP EXTENSION pgcrypto;

-- 2.0 --> 1.2
CREATE EXTENSION pgcrypto;
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
ALTER EXTENSION pgcrypto UPDATE TO '1.2';
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
SELECT * FROM allfuncs;
DROP EXTENSION pgcrypto;

-- 1.2 --> 2.0
CREATE EXTENSION pgcrypto WITH VERSION '1.2';
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
ALTER EXTENSION pgcrypto UPDATE TO '2.0';
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
SELECT * FROM allfuncs;
DROP EXTENSION pgcrypto;

/* ------------------------------------------------------------------------------------------------
 * part 2: core functions
 * ------------------------------------------------------------------------------------------------
 */
CREATE EXTENSION pgcrypto;

-- 1 desencrypt
SELECT dbms_obfuscation_toolkit.desencrypt(strtoraw('11111111'), strtoraw('11111111')) FROM dual;
SELECT dbms_obfuscation_toolkit.desencrypt(strtoraw('1111111111111111'), strtoraw('11111111')) FROM dual;

-- 2 desdecrypt
SELECT rawtostr(dbms_obfuscation_toolkit.desdecrypt(hextoraw('655EA628CF62585F'), strtoraw('11111111'))) FROM dual;
SELECT rawtostr(dbms_obfuscation_toolkit.desdecrypt(hextoraw('655EA628CF62585F20D3B8A6E657876B'), strtoraw('11111111'))) FROM dual;

-- 3 des3encrypt
SELECT dbms_obfuscation_toolkit.des3encrypt(strtoraw('11111111'), strtoraw('1111111122222222'), 0, strtoraw('11111111')) FROM dual;
SELECT dbms_obfuscation_toolkit.des3encrypt(strtoraw('1111111111111111'), strtoraw('1111111122222222'), 0, strtoraw('11111111')) FROM dual;

-- 4 des3decrypt
SELECT rawtostr(dbms_obfuscation_toolkit.des3decrypt(hextoraw('0D28E17571051319'), strtoraw('1111111122222222'), 0, strtoraw('11111111'))) FROM dual;
SELECT rawtostr(dbms_obfuscation_toolkit.des3decrypt(hextoraw('0D28E17571051319ACCE2D19D9AED5C8'), strtoraw('1111111122222222'), 0, strtoraw('11111111'))) FROM dual;

-- 5 des3encrypt -- without iv
SELECT dbms_obfuscation_toolkit.des3encrypt(strtoraw('11111111'), strtoraw('1111111122222222')) FROM dual;
SELECT dbms_obfuscation_toolkit.des3encrypt(strtoraw('1111111111111111'), strtoraw('1111111122222222')) FROM dual;

-- 6 des3decrypt -- without iv
SELECT rawtostr(dbms_obfuscation_toolkit.des3decrypt(hextoraw('7934131269E334A2'), strtoraw('1111111122222222'))) FROM dual;
SELECT rawtostr(dbms_obfuscation_toolkit.des3decrypt(hextoraw('7934131269E334A2BCC64878CC5A075A'), strtoraw('1111111122222222'))) FROM dual;

/* ------------------------------------------------------------------------------------------------
 * part 3: different args
 * ------------------------------------------------------------------------------------------------
 */
-- 1 des
CREATE TABLE tplain (id INT, plain TEXT, key TEXT);
INSERT INTO tplain VALUES
 (1, '', ''),
 (2, NULL, NULL),
 -- different plain
 (11, NULL, '88888888'),
 (12, '', '88888888'),
 (13, '1', '88888888'),
 (14, '7777777', '88888888'),
 (15, '88888888', '88888888'),
 (16, '999999999', '88888888'),
 (17, '17171717171717171', '88888888'),
 (18, '242424242424242422424242','88888888'),
 -- different key
 (31, '88888888', NULL),
 (32, '88888888', ''),
 (33, '88888888', '1'),
 (34, '88888888', '7777777'),
 (37, '88888888', '88888888'),
 (38, '88888888', '999999999'),
 (37, '88888888', '17171717171717171'),
 (38, '88888888', '242424242424242422424242');

CREATE TABLE tcipher (id INT, key TEXT, cipher RAW);
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 1;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 2;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 11;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 12;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 13;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 14;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 15;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 16;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 17;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 18;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 31;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 32;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 33;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 34;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 35;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 36;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 37;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 38;
SELECT id,cipher,length(cipher) FROM tcipher ORDER BY id;

SELECT id,rawtostr(dbms_obfuscation_toolkit.desdecrypt(cipher, strtoraw(key))) FROM tcipher ORDER BY id;

DROP TABLE tplain,tcipher;

-- 2 3des
CREATE TABLE tplain (id INT, plain TEXT, keymod INT, key TEXT, iv TEXT);
INSERT INTO tplain VALUES
 (1, '', 0, '', ''),
 (2, NULL, 0, NULL, NULL),
 -- different plain
 (11, NULL, 0, '1616161616161616', '88888888'),
 (12, '', 0, '1616161616161616', '88888888'),
 (13, '1', 0, '1616161616161616', '88888888'),
 (14, '7777777', 0, '1616161616161616', '88888888'),
 (15, '88888888', 0, '1616161616161616', '88888888'),
 (16, '999999999', 0, '1616161616161616', '88888888'),
 (17, '17171717171717171', 0, '1616161616161616', '88888888'),
 (18, '242424242424242422424242',0, '1616161616161616', '88888888'),
 -- different keymod
 (31, '1616161616161616', NULL, '1616161616161616', '88888888'),
 (32, '1616161616161616', -1, '1616161616161616', '88888888'),
 (33, '1616161616161616', -1.1, '1616161616161616', '88888888'),
 (34, '1616161616161616', 1.1, '1616161616161616', '88888888'),
 (35, '1616161616161616', 2, '1616161616161616', '88888888'),
 (36, '1616161616161616', '0', '1616161616161616', '88888888'),
 (37, '1616161616161616', 1, '242424242424242422424242', '88888888'),
 -- different key
 (51, '1616161616161616', 0, NULL, '88888888'),
 (52, '1616161616161616', 0, '', '88888888'),
 (53, '1616161616161616', 0, '1', '88888888'),
 (54, '1616161616161616', 0, '7777777', '88888888'),
 (55, '1616161616161616', 0, '88888888', '88888888'),
 (56, '1616161616161616', 0, '999999999', '88888888'),
 (57, '1616161616161616', 0, '17171717171717171', '88888888'),
 (58, '1616161616161616', 0, '242424242424242422424242', '88888888'),
 (59, '1616161616161616', 0, '272727272727272727272727272', '88888888'),
 (61, '1616161616161616', 1, NULL, '88888888'),
 (62, '1616161616161616', 1, '', '88888888'),
 (63, '1616161616161616', 1, '1', '88888888'),
 (64, '1616161616161616', 1, '7777777', '88888888'),
 (65, '1616161616161616', 1, '88888888', '88888888'),
 (66, '1616161616161616', 1, '999999999', '88888888'),
 (67, '1616161616161616', 1, '17171717171717171', '88888888'),
 (68, '1616161616161616', 1, '242424242424242422424242', '88888888'),
 (69, '1616161616161616', 1, '272727272727272727272727272', '88888888'),
 -- different iv
 (81, '1616161616161616', 1, '242424242424242422424242', NULL),
 (82, '1616161616161616', 1, '242424242424242422424242', ''),
 (83, '1616161616161616', 1, '242424242424242422424242', '1'),
 (84, '1616161616161616', 1, '242424242424242422424242', '7777777'),
 (85, '1616161616161616', 1, '242424242424242422424242', '88888888'),
 (86, '1616161616161616', 1, '242424242424242422424242', '999999999'),
 (87, '1616161616161616', 1, '242424242424242422424242', '17171717171717171'),
 (88, '1616161616161616', 1, '242424242424242422424242', '242424242424242422424242'),
 (89, '1616161616161616', 1, '242424242424242422424242', '272727272727272727272727272');

CREATE TABLE tcipher (id INT, CIPHER RAW, keymod INT, key TEXT, iv TEXT);
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 1;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 2;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 11;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 12;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 13;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 14;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 15;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 16;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 17;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 18;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 31;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 32;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 33;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 34;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 35;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 36;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 37;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 51;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 52;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 53;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 54;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 55;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 56;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 57;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 58;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 59;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 61;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 62;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 63;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 64;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 65;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 66;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 67;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 68;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 69;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 81;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 82;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 83;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 84;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 85;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 86;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 87;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 88;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 89;
SELECT * FROM tcipher;

SELECT id, rawtostr(dbms_obfuscation_toolkit.des3decrypt(cipher, strtoraw(key), keymod, strtoraw(iv))) FROM tcipher ORDER BY id;

DROP TABLE tplain, tcipher;

/* ------------------------------------------------------------------------------------------------
 * part 4: other functions
 * ------------------------------------------------------------------------------------------------
 */
SELECT length(dbms_obfuscation_toolkit.desgetkey(strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'))) FROM dual;
SELECT length(dbms_obfuscation_toolkit.des3getkey(0, strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'))) FROM dual;
SELECT length(dbms_obfuscation_toolkit.des3getkey(1, strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'))) FROM dual;
SELECT dbms_obfuscation_toolkit.md5(strtoraw('1111111111111111')) FROM dual;

CREATE TABLE deskey(id INT, key RAW);
CREATE TABLE des3key0 (id INT, key RAW);
CREATE TABLE des3key1 (id INT, key RAW);

INSERT INTO deskey SELECT generate_series(1, 1000),
 dbms_obfuscation_toolkit.desgetkey(strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'));
INSERT INTO des3key0 SELECT generate_series(1, 1000),
 dbms_obfuscation_toolkit.des3getkey(0, strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'));
INSERT INTO des3key1 SELECT generate_series(1, 1000),
 dbms_obfuscation_toolkit.des3getkey(1, strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'));

CREATE TABLE allcnt (cnt INT);
INSERT INTO allcnt SELECT count(*) FROM deskey GROUP BY key;
INSERT INTO allcnt SELECT count(*) FROM des3key0 GROUP BY key;
INSERT INTO allcnt SELECT count(*) FROM des3key1 GROUP BY key;
SELECT cnt,count(*) FROM allcnt GROUP BY cnt;

-- test (need to spend too much time)

-- CREATE TABLE moretime(id INT, key RAW);
-- INSERT INTO moretime SELECT generate_series(1, 100000),
-- dbms_obfuscation_toolkit.desgetkey(strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'));
-- -- 预期 key列重复的字符不多
-- SELECT * FROM moretime ORDER BY key ASC LIMIT 10;
-- SELECT * FROM moretime ORDER BY key DESC LIMIT 10;
-- DROP TABLE moretime;

DROP TABLE deskey, des3key0, des3key1, allcnt;

DROP EXTENSION pgcrypto;
RESET search_path;
DROP SCHEMA pgcrypto_2_text CASCADE;

海量 1 设计 oracle加密函数

Tue, 25 Feb 2025 09:49:00 +0800

1

设置默认版本

contrib/pgcrypto/pgcrypto.control

defaultl_version = '2.0'
dbcompatibilities = 'A, B, PG'

生成同名的sql文件

touch contrib/pgcrypto/pgcrypto-2.0.sql

安装sql文件

# pgcrypto.control与pgcrypt.*.sql文件
ll $GAUSSHOME/share/postgresql/extension | grep pgcrypto

加载插件

# 执行：CREATE EXTENSION pgcrypto
 ..
 CreateExtension
 check_valild_extension_name # 检查插件名：要求不含 '-'、不含'..'等路径字符
 get_extension_oid
 heap_open('pg_extension')
 systable_beginscan # 遍历系统表 pg_extension：确保插件存在
 read_extension_control_file
 parse_extension_control_file
 get_extension_control_filename
 sprintf("{share}/extension/{extension_name}.control")
 ParreConfigFp
 # 获取 directory, default_version, module_pathname, dbcompatibilities 等参数
 get_extension_script_filename
 get_extension_script_direcotry
 if name is 'pgcrypto':
 sprintf("{script_dir}/crypto-a.sql")
 read_extension_script_file
 InsertExtensionTuple # 插入系统表 pg_extension
 execute_extension_script
 ApplyExtensionUpdates

海量 1 需求 oracle加密函数

Wed, 19 Feb 2025 16:20:00 +0800

1 简介

1.1 目的

早期版本的oracle提供一个包含多个加密函数的包，用户可通过SQL语法调用加密函数，实现数据加密功能。本文主要介绍以下几点：

oracle加密包的功能与使用方法
vastbase实现oracle加密包
vastbase加密包的功能与使用方法

本文档可指导开发者、测试者熟悉vastbase加密包特性的功能场景。

本文档的内容已被上传至tapd，tapd上，排版更好看，测试用例更方便复制。建议直接从tapd上查看本文档原文： https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007194

1.2 适用范围

vastbase 3.0.8及之后版本。

1.3 术语定义、首字母缩写词和缩略语

DES：Data Encryption Standard，数据加密标准，一种早期通用的加密算法
3DES：Triple DES，基于DES演进的一种早期通用的加密算法
MD5：Message-Digest Algorithm，一种早期通用的数据摘要算法

1.3 参考资料

oracle dbms_obfuscation_toolkit 函数介绍：https://docs.oracle.com/cd/A97630_01/appdev.920/a96590/adgsec04.htm
oracle dbms_obfuscation_toolkit 函数参数：https://docs.oracle.com/cd/B10500_01/appdev.920/a96612/d_obtoo2.htm
tapd上，本需求文档： https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007194
tapd上，本需求的测试用例： https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007197

2 支持oracle加密插件dbms_obfuscation_toolkit

2.1 功能简述

早期版本oracle提供7个内置加密函数。早在4年或更早之前的旧版本vastbase中，也提供7个与oracle一致的加密函数，这7个函数，函数名、函数入参与oracle一致，但是，6个函数输出、15个函数参数约束与oracle不一致，本特性将重构这些加密函数，确保函数的输出、约束等与oracle一致。

一、基础知识

加密的原理
加密算法有很多种，不同场景中，适合的加密算法类型不同。对存储数据加密，通常采用对称密码算法，此处主要介绍对称密码算法：
- 加密原理：输入1个明文，输入1个密钥，对明文和密钥进行一些可逆的运算（比如异或，代换），可得到1个密文。密钥通常是随机生成的
- 加密算法：DES算法，发布于1977年，已确定为不安全加密算法。3DES算法，调用3次DES算法，生成3个密钥，安全性与DES差别不大，也属于不安全的加密算法。AES算法，发布于2001年，通用的国际标准，替代不安全的DES算法

数据库加密函数
几乎所有数据库，都提供内置加密函数，让用户通过SQL语句调用。最典型的场景如下：

-- 假设，数据库提供函数encrypt(明文，密钥，加密算法)，输出为密文
-- 用户想表't1'中存储数据'shenkun'，则存储的语法如下：（用户自己保管密钥）
INSERT INTO t1 VALUES (encrypt('shenkun', '一串随机的密钥', 'aes'));

二、Oracle加密包

早期版本的oracle中，包含1个名为dbms_obfuscation_toolkit的包，提供7个函数，主要实现加密、解密等功能：

版本信息：oracle 8i版本开始提供，oracle 10g版本开始不被推荐使用，由dbms_crypto代替，oracle 21c版本正式移除
函数列表：
- 生成随机数：desgetkey(seed) -> key
- 加密：desencrypt(input, key) -> encrypted_data
- 解密：descdecrypt(input, key) -> decrypted_data
- 生成随机数：des3getkey(which=>0, seed) -> key
- 加密：des3encrypt(input, key, which=>0, iv=>012345678abcdef) -> encrypted_data
- 解密：des3decrypt(input, key, which=>0, iv=>012345678abcdef) -> decrypted_data
- 哈希：md5(input) -> checksum
函数参数：函数参数有2种数据类型：varchar2, raw。与raw类型相比，如果是varchar2类型，参数名需加上_string后缀。比如，raw类型的入参名为input，则varcha2类型入参名为input_string
函数限制：
- desgetkey：seed长度最短为80字节
- desencrypt：input长度是8字节的整数倍；key最短为8字节，超过8字节的部分被丢弃
- descdecrypt：input长度是8字节的整数倍；key最短为8字节，超过8字节的部分被丢弃
- des3getkey: seed长度最短为80字节
- des3encrypt：input长度是8字节的整数倍；which为0时，key最短为16字节，超过16字节的部分被丢弃；which为1时，key最短为24字节，超过24字节的部分被丢弃
- des3dencrypt：input长度是8字节的整数倍；which为0时，key最短为16字节，超过16字节的部分被丢弃；which为1时，key最短为24字节，超过24字节的部分被丢弃
- md5：无
参考文档
- 函数介绍：函数背景、注意事项等：https://docs.oracle.com/cd/A97630_01/appdev.920/a96590/adgsec04.htm
- 函数参数：参数类型、调用示例等：https://docs.oracle.com/cd/B10500_01/appdev.920/a96612/d_obtoo2.htm

以下是上述函数的调用示例：

传统安全 1 密码学

Tue, 21 Jan 2025 13:55:00 +0800

1 密码学综述

本文主要总结常见的密码算法与协议，并不详细介绍原理

密码算法
- 对称密码算法
- 非对称密码算法
- 哈希算法
- 完整性校验算法
其他算法
- 随机数生成算法
- 密钥派生算法

2 密码算法

2.1 对称加密算法

对称加密算法的基本原理是，输入明文、密钥，对明文进行分组，对每组明文进行多轮线性、非线性运算，比如异或、代换等，得到密文。
常见的对称加密算法如下：

算法	发布时间	分组长度	密钥长度	算法
DES	1977	64	64	16 x 置换（E扩展、异或、代换、P置换）
3DES	-	-	-	-
IDEA	1990	-	-	-
AES	2001	128	128/192/256	10/12/14 x 矩阵运算(字节代换、行移位、列混合、异或)
SM4	2012	128	128	32 x 分组运算（异或、代换、移位）
SM1	-	128	128	未公开
SM7	-	128	128	未公开

在实现加密的过程中，还有几个基础知识：

密钥扩展：加密时，会迭代很多轮，每一轮都用1个轮密钥。1个原始密钥，扩展为多个的轮密钥。

加密模式：一个原始明文，分为多个明文组，组与组之间的组合方式如下：

模式	中文	描述
ECB	电子密码本	不同的明文块，用相同的密钥
CBC	密码分组链接	上1密文块，与下一明文块异或
CTR	计数器模式	密钥加密计数器生成密钥流，密文块与密钥流异或
CFB	密码反馈模式	-
OFB	输出反馈模式	与CFB类似

常见算法的具体实现原理如下：

传统安全 5 数据库加密

Tue, 21 Jan 2025 13:55:00 +0800

1 数据库加密的背景

1.1 数据库安全机制

应用将数据发送给数据库后，数据库组织数据，将数据存储在文件中，并提供一系列安全机制，保护数据安全。比如：

安全传输：基于TLS等安全协议，保证数据在应用与数据库之间传输的机密性、完整性等，避免攻击者对传输中的数据进行窃听、伪造、篡改等
身份认证：基于IP、口令、证书等鉴别用户身份，避免攻击者非法访问数据库
访问控制：通过多种访问控制机制，限制攻击者对数据库对象的的访问范围
安全审计：记录攻击者在数据库中执行的各项操作
数据脱敏：对隐私数据库进行脱敏处理，避免攻击者查看数据库中的隐私数据
数据防篡改：基于区块链等技术，记录数据变化情况，识别攻击者非法篡改磁盘上的数据库文件

1.2 数据泄露问题

在很多针对数据库的攻击行为中，攻击者可绕过上述数据库安全机制，直接从磁盘窃取数据，造成数据泄露问题。
为了规避此类问题，有效的方案是对数据进行加密，使攻击者仅能从磁盘获取数据密文，无法解密数据，从而解决数据泄露问题。

1.3 数据库加密方案分类

数据库加密方案较多，本博客仅介绍一些常见的，且适用于大部分场景的加密方案。

一、按加密位置分类

首先，按加密位置分类，可分为以下6种：

各方案的基本原理如下：

应用加密：应用先将数据加密，再使用SQL语句，将数据密文存储至数据库
全密态加密：数据库驱动识别并加密SQL语法中的数据，同时自动解密SQL查询结果。部分数据库产品提供此功能
网关或代理加密：在应用与数据库之间的中继节点中，比如代理或网关中，通过解析网络流量，自动识别与加解密流量中的数据，包括SQL语法中的数据与SQL查询结果。很多云服务、安全厂商提供此服务
加密函数：数据库内置加密函数或存储过程，应用可通过SQL语法主动调用加密函数。大部分数据库产品提供此功能
透明加密：数据库将数据存储至磁盘前，自动加密数据，数据库从磁盘读取数据时，自动解密数据。大部分数据库产品提供此功能
磁盘加密：操作系统处理磁盘读写请求时，自动加密与解密读写到的数据。部分操作系统或云存储服务提供此功能

二、按加密定义方式分类

上述加密方案中，按应用是否主动感知加密过程，可将其分为非自动加密与自动加密。

非自动加密
以应用加密为例，用户加密数据的流程如下：

-- 1 首先，定义表
CREATE TABLE t1 (c1 TEXT, c2 TEXT);
-- 2 假设需向t1中存储数据 (1, 'data1')，应用需要先将数据加密，在通过SQL语法将加密后的数据存储至数据库
-- 3 存储数据
INSERT INTO t1 VALUES ('encrypted[1]', 'encrypted[data1]');
-- 4 查询数据时，查询结果为数据密文，数据无法直接使用
SELECT * FROM t1; -- 查询结果为：('encrypted[1]', 'encrypted[data1]')
-- 5 应用需自行解密查询结果，最终解密后得到原始数据 (1, 'data1')

此类加密方案中，每次涉及数据读写操作时，都需要主动进行加密与解密，操作复杂。

海量 3 需求 pg_hba.conf加密

Tue, 01 Apr 2025 15:42:00 +0800

1 需求背景

客户使用vb什么版本？ 2215
客户的要求：

2 需求分析

2.1 适配点

在使用vastbase的多个阶段，都可能涉及pg_hba.conf

编译安装
初始化
升级
配置
- gs_guc修改pg_hba
- 手动编辑pg_hba
启动
运维
- pg_backup
- pg_rewind
- vb_ctl restart

2.2 代码流程

编译

初始化

main # initdb.cpp
 canonicalize_path # PGDATA
 find_other_exec # 在gs_initdb bin目录下，查找gaussdb bin
 # 在$GAUSSHOME/share/postgrsql目录下，检查以下文件是否存在
 check_input('postgres.bki, postgres.description, pg_hba.conf.sample, postgresql.conf.sample, ..., system_views.sql, ...')
 check_locale_encoding
 init_log
 gs_getenv_r('GAUSSLOG')
 canonicalize_path('$PGDATA/PG_VERSION')
 fprintf(PG_MAJORVERSION = '9.2')
 setup_config
 readfile("postgresql.conf.sample")
 readfile("pg_hba.sample")
 writefile("pg_hba.conf")
 bootstrap_template1
 write_version_file
 setup_auth
 get_set_pwd
 setup_depend
 load_plpgsql
 setup_sysviews

升级
配置
启动
```
pg_ctl
```

运行

PostmasterMain # postmaster 线程
 InitializeGUCOptions
 getopt_r
 load_hba # 加载hba
 ServerLoop
 ConnCreate
 StreamConnection
 BackendStartup
 PostgresMain # postgres 线程
 InitBackendWorker
 InitSession
 CheckAuthentication
 PerformAuthentication
 port->protocol_config->fn_authenticate
 ClientAuthentication
 hba_getauthmethod
 check_hba
 g_instance.libpq_cxt_comm_parsed_hba_lines # 读取缓存的hba
 if init_user:
 get_default_auth_method
 else:
 check_hostname
 sendAuthRequest
 recv_and_check_password_packet # 接收客户端的password
 crypt_verify
 for (;;)
 ReadCommand
 exec_simple_query('SQL')

SIGHUB_handler
 load_hba

运维

数据库安全 0 postgresql表级透明加密

Tue, 21 Jan 2025 13:55:00 +0800

1 特性背景
2 实现方案
3 关键设计
4 特性源码
参考

1 特性背景

2 实现方案

2.1 系统表

1. pg_key_info 密钥信息

keyoid	keyname	type	alrotithm	storage	access	protect	create_time	round
1	mk_1	master_key	any	localkms	path=./keyfile	$pass1	2024/02/01 13:01:01	-
2	dk_1	date_key	aes_256_cbc	database	m100.d100.b1.i2	mk1	2024/02/01 13:01:01	0

2. pg_key_data 密钥数据

oid	keydata	algorithm
3	abcd1234	aes_256

3. pg_encryption 加密对象

type	name	oid	special	protect	oldest_round
table	t1	100	-	dk_1	1

2.2 定义表

定义表
定义表的语法与非加密表一致，我们通过单独的语法定义ENCRYPTION。

数据库安全 5 全密态

Wed, 24 Jun 2026 14:47:00 +0800

0 基础调研
1. 一、运算符
2. 二、数据类型
1 架构设计
1. 工作计划
2 驱动加密 - 实现
3 机密计算 - 实现
4 测试用例
附录：专利
附录：AI
1. 代码要求：
附录：参考文献

0 基础调研

一、运算符

运算符
以int4为例：select proname from pg_catalog.pg_proc where proname like '%int4%' order by proname;
- 一、比较运算符函数

数据库安全 9 透明加密

Tue, 21 Jan 2025 13:55:00 +0800

1 透明加密背景

在另一篇博客中，已经讨论了几个话题：

数据泄露风险
加密方案对比
透明加密基本原理

因此，本篇博客直接进入主题，介绍openGauss透明加密特性。

2 透明加密使用

2.1 开启透明加密

2.2 定义加密表

CREATE TABLE t1 (c1 INT, c2 TEXT) WITH (enable_tde=on);

2.3 验证数据加密

3 透明加密设计

4 透明加密原理

1 概述

1.1 模块

heapam -> buffer -> smgr -> page

1 概述

1.1 功能

用户创建表时，通过SQL语句指定表是否加密
数据库将数据页写入磁盘时，判断如果数据页属于加密表，对数据先加密在存储
数据库从磁盘读取数据页时，判断如果数据页已被加密，读取后马上解密

1.2 适配点

初始化page
存储page
读取page
生成xlog记录：考虑初始化pagee
重放xlog记录：考虑初始化page

1.3 kun tde

2 调用关系

2.1 初始化数据页

PageInit

PageInit(Page page, Size pageSize, Size specialSize)
 heap_xlog_insert()
 heap_xlog_multi_insert()
 heap_xlog_update()
 heap_xlog_visible()
 raw_heap_insert()
 PageGetTempPageCopySpecial()
 fill_seq_with_data()
 seq_redo()
 brin_page_init()
 lazy_scan_heap()
 GinInitPage()
 GISTInitBuffer()
 _hash_pageinit()
 _bt_pageinit()
 SpGistInitPage()
 vm_readbuf()
 vm_extend()
 XLogRecordPageWithFreeSpace()
 fsm_readbuf()
 fsm_extend()

image

2.2 写入数据页

smgrextend

调用栈：

WAL 加密模块设计

Mon, 07 Sep 2026 15:30:00 +0800

假设集群里已经存在表级透明加密模块，在此基础上设计一个高性能、高易用性的 WAL 加密模块。

WAL 加密的难点几乎不在"加密"本身，而在两件事：同一个 8KB 页会被反复重写，以及恢复路径要在拿不到 catalog 的时候就能解密。下面按设计决策的顺序展开。

1 威胁模型

先划清边界，因为它直接决定后面几个取舍。

要防的：磁盘 / 备份 / 归档介质被拖走；DBA 之外的运维人员直接读 pg_wal/；WAL 归档到对象存储。
不防的：有 root 权限的在线攻击者（内存里必然有明文）、旁路攻击。

1.1 为什么不用 dm-crypt 了事

如果只是防"介质丢失"，块设备加密（LUKS/dm-crypt）性价比高得多。在数据库内核里做 WAL 加密，真正的理由只有三个：

密钥要由数据库自己管，不能落在 OS 层（密评 / 国测要求）；
归档件要天然带密；
和已有的表级 TDE 共用一套密钥体系。

设计要始终对齐这三个理由，否则很容易做成一个又慢、又没多大意义的模块。

1.2 FPI 是必须堵的洞

既然表级 TDE 已经存在，那么 FPI（full page image）就是个必堵的泄漏点。

如果 TDE 是在 smgr 层做的（缓冲区里是明文、写盘时加密），那么 WAL 里的 FPI 记录的是明文页 —— 加密表的数据会原封不动地漏进 WAL。

只要集群里存在任何一张加密表，WAL 加密就必须强制开启，不能是两个独立开关。

实现上做成一个集群级的 data_encryption = on，或者至少让 CREATE ENCRYPTION POLICY 在 WAL 加密未开启时直接报错。这是易用性设计里最重要的一条：不要把一个"配错了就静默泄密"的组合留给用户。

专利全密态索引

Wed, 15 Jul 2026 19:25:00 +0800

1 专利名称

一种基于可信执行环境的数据库密态索引访问方法、系统及介质

2 技术背景

全密态数据库：一种由数据库提供的安全特性，指数据库在处理数据的过程中，确保数据在传输、计算、存储等全生命周期阶段，于任何不可信的介质或环境中，始终处于加密状态。
全密态数据库实现方案：目前，业界较成熟的方案，是基于可信执行环境，实现全密态数据库，该方案主要分为2个模块：1)驱动加密：应用向数据库发送SQL语句时，应用侧的数据驱动自动加密SQL语句中的数据，数据库接收与处理数据密文。2)机密计算：数据库无法再密文上进行计算，将密文发送至可信执行环境（TEE）中，由可信模块完成解密与计算。
数据库索引结构：数据库中，最常见的索引为b+树索引。以tpcc测试模型为例，数据量低于100亿条时，b+树一般不超过4层。每一层的节点，即索引节点，是固定大小的page，分root index-page，internal index-page，leaf index-page。1个index-page中，存储多个index-item。其中，root和internal index-page中的index-item，存储数据和下一层index-page的位置。leaf index-page中的index-item，存储数据和table-page的位置。
加密性能：在加解密数据时，影响加密性能的因素中，加密次数的影响远高于数据长度。例如，1次加密8k数据，比40次加密200字节数据的性能高10+倍。
密态索引：在全密态数据库中，数据库只存储数据密文，在等值、范围查询等场景，为提高查询效率，避免全表扫描，需要在密文上构造索引。因此，需要见密文传输至可行执行环境TEE中，在TEE中临时解密数据，比较数据大小，构造索引。
现有方案缺陷：在构造密态索引时，现有方案存在以下缺陷：1)交互开销高：以索引元组为粒度，与TEE交互，交互次数多，交互开销高。2)加解密开销高：在索引页内比较元组大小时，需要多次解密索引元组。对于顶层的索引页，访问评率高，加解密频率也较高。3)内核修改多：为适配TEE，对索引构造、索引查询、并发控制等修改多，破坏生态兼容性等。

3 发明内容

发明目的：本发明针对在密文数据上构造索引、扫描索引的场景，提供一种通用的、高性能、低改造的方案，基于可信执行环境，大幅降低交互开销、加解密开销，并且，充分复用索引分裂、并发访问的机制，对内核侵入修改度低。
技术方案：
本发明的关键创新如下：

构造索引：应用插入数据时，驱动以字段为粒度，加密数据。数据库接收数据密文，TEE解密数据，构造索引，并以索引页为粒度，重新加密数据。
访问索引：结合索引的访问特点，每个index-item不独立加密与解密，每次以index-page为粒度加密与解密，降低加解密次数。
发送索引：数据库向TEE发生索引时，每次以index-page为粒度发送，降低交互次数。
缓存索引：在TEE中，针对索引中root和internal page访问频率高、修改频率低的特点，缓存解密后的page，降低解密次数、与TEE的交互次数。
内核改造：数据库中，访问索引时，只在需要比较大小时，才与TEE交互，保留已有索引分裂、并发访问机制。

以tpcc模型为例，当warhouse为10000时：

基表：bmsql_customer表中，数据行数为3亿，表大小约250G
索引：bmsql_customer主键索引中，index-item数为3亿，索引文件大小约9.5G，索引层数为4层，每层page数量分别：1、17、4400、114万，每个page中page-item数量约260个。插入1条数据，index-page平均分裂次数为0.0034次。

在该场景中，使用本发明的方案，考虑index-page分裂、TEE缓存偶尔未命中等所有可能产生额外交互、加密、解密的情况下：

场景	与TEE交互次数	加密次数（TEE内）	解密次数（TEE内）
插入1条数据	< 2.01	< 1.01	< 1.01
查询1条数据	< 2.01	0	< 1.01
删除1条数据	< 2.01	< 1.01	< 1.01

4 附图及附图的简单说明

4.1 密态索引结构

密态索引中，所有index-page中，只存储数据密文。在TEE中，以page为粒度加密，PageHeader、PageTail中，不存储用户数据，无需加密。
此处，以一个简单的3层索引为例，展示明文索引、密态索引的区别：

4.2 密态索引插入流程

在图1的示例中，向索引中插入1条数据，流程如下：

上述流程中，步骤12至20可通过缓存优化。以tpcc为例，index-item为3亿时，索引层数为4，索引文件大小约9.5G，root page数为1，internal page数为17+4000，缓存大小为31.38MB。

5 具体实施方式

5.1 创建密态索引

管理员：创建密钥 CREATE DATA KEY dk1(..);
数据库驱动：通过密钥服务或密码机生成密钥，缓存密钥，向数据库发送密钥信息
数据库：在系统表中，存储密钥信息，包括：密钥名、密钥Oid等。
管理员：创建加密表和索引：CREATE TABLE t1(c1 INT ENCRYPTED BY dk1, c2 TEXT)，CREATE INDEX i1 ON t1(c1);
数据库：存储加密信息，包括：表名、列名、密钥名等。

5.2 向索引插入1条数据

前置条件：已创建密态索引
应用：连接数据库
数据驱动：连接数据库，查询加密信息、密钥信息，并缓存
数据库驱动：从密钥服务或密码机获取密钥，与可信执行环境建立安全通道，并传输密钥
可信执行环境：缓存密钥
应用：向数据库存储数据：INSERT INTO t1 VALUES (13, ‘data1’);
数据库驱动：对SQL进行语法解析，识别加密列字段，并加密字段，并改写SQL：INSERT INTO t1 VALUESS (cipher[13], ‘data1’);
数据库：向基表t1插入数据(cipher[13], ‘data1’)，准备构造索引
数据库：向TEE中，发送密文 cipher[13]
可信执行环境：解密cipher[13]，获取明文(13)
可信执行环境：查找缓存的root page，如果未找到，请求数据库发送root page，解密并缓存root page
可信执行环境：在root page中，二分查找，获取internal page位置
可信执行环境：查找缓存的internal page，如果未找到，请求数据库发送internal page，解密并缓存internal page
可信执行环境：在internal page中，二分查找，获取leaf page位置
可信执行环境：请求数据库发送leaf page。解密leaf page
可信执行环境：如果leaf page已满，触发分裂流程，此处不展开说明
可信执行环境：在leaf pag中，二分查找，获取插入位置
可信执行环境：在leaf page中，插入数据(13, 基表t1中13的存储位置)
可信执行环境：加密leaf page，向数据库返回加密后的leaf page
数据库：重新存储加密后的leaf page

5.3 从索引中查找1条数据

查询流程，与插入流程大部分一致：

高质量专项全密态机密计算

Mon, 19 Jan 2026 18:37:00 +0800

1 架构

1.1 整体架构

全密态数据库是一种由数据库提供的安全特性，指数据库在处理数据的过程中，确保数据在传输、计算、存储等全生命周期阶段，于任何不可信的介质或环境中，始终处于加密状态。不可信环境包括：网络、内存、磁盘等。以常见的拓扑模型为例，在使用数据库的过程中，威胁面较广：

全密态数据库中，对于传输、存储安全，采用驱动加密方案。应用向数据库发送数据时，先在驱动中加密数据，再发送数据密文。应用从数据库接收数据时，先接收数据密文，再在驱动中解密数据。数据在网络、磁盘、服务端内存中，均处于加密状态。基本架构如下图所示：

全密态数据库中，对于计算安全，采用机密计算方案。驱动加密方案，解决传输、存储安全，但是，数据库端无法在密文上计算。为解决计算问题，业界有两种方案：

基于密码学算法的密文计算方案：通过密码学算法，让数据库在直接在密文上进行计算，例如保序加密、可搜索加密、同态加密等
基于硬件隔离的机密计算方案：在CPU、内存中，划分逻辑独立的可信执行环境，让数据库在可信执行环境中解密数据密文，进行计算。

在充分对比安全性、功能完备性、性能、实现难度等特点，选择机密计算方案。结合驱动加密方案、机密计算方案，全密态数据库整体架构如下图所示：

全密态数据库中，对于加密模型，采用多级密钥方案。数据由数据密钥加密，密钥由主密钥加密，主密钥由根密钥加密。在驱动加密模块中，只能获取数据密钥，无法获取主密钥。在更安全的加密方案中，驱动加密模块无法获取数据密钥，由硬件加密机加密。在数据库端，仅存储密钥信息，无法获取密钥。全密态数据库加密模型如下图所示：

2 流程

2.1 整体流程

使用全密态数据库时，用户需定义主密钥、数据密钥、加密表，在执行存储、查询数据时，全密态数据库自动完成加密、解密、计算等操作。完整的使用流程如图所示：

3 设计

3.1 驱动加密

3.2 机密计算

一、技术调研

纯软路线
- 同态加密
软硬路线
- x86
  - cpu
    - sgx：硬件
    - tdx：硬件
  - 固件
    - me：出厂自带
  - 软件
    - sgx driver
- amd
  - cpu
    - sev：Secure Encrypted Virtualization，CPU扩展电路，为每台虚拟机分配内存密钥，运行时加密整段内存。需BIOS开启。
    - sev-snp/sev-es
  - 固件
    - psp
  - 软件
    - kvm sev
- arm
  - cpu
    - trust-zone：每个核新增总线，
  - 固件
    - arm trusted fimware
  - 软件
    - op-tee
tee: https://github.com/OP-TEE/build

数据库安全传输加密

Wed, 21 May 2025 09:37:00 +0800

非国密

生成证书
数据库服务端：配置证书、配置传输加密算法
数据库客户端：配置证书

# 检查openssl版本
which openssl
 # 确保使用的是vastbase发布包中的openssl，而非操作系统中的openssl

cp $GAUSSHOME/share/sslcert/gsql/openssl.cnf ./
export OPENSSL_CONF=`pwd`/openssl.cnf

# 创建文件
mkdir cert
cd cert
mkdir ./demoCA ./demoCA/newcerts ./demoCA/private
chmod 700 ./demoCA/private
echo '01'>./demoCA/serial
touch ./demoCA/index.txt

# ca
openssl genrsa -out ./demoCA/private/cakey.pem 2048
openssl req -new -key ./demoCA/private/cakey.pem -out ./demoCA/private/ca_cert_req.pem -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=root"
openssl x509 -req -in ./demoCA/private/ca_cert_req.pem -days 7300 -signkey ./demoCA/private/cakey.pem -out ./demoCA/cacert.pem

# server
openssl genrsa -out server.key 2048
openssl req -new -key server.key -out server.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=server"
openssl x509 -req -in server.csr -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -CAcreateserial -out server.crt

# client
openssl genrsa -out client.key 2048
openssl req -new -key client.key -out client.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=client"
openssl x509 -req -in client.csr -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -CAcreateserial -out client.crt

# 查看内容
openssl x509 -in client.crt -text

# 设置权限
chmod 600 client.key
chmod 600 client.crt
chmod 600 server.key
chmod 600 server.crt
chmod 600 ./demoCA/cacert.pem

export CERT=`pwd`
echo '
export CERT=`pwd`
export PGSSLMODE=verify-ca

export PGSSLROOTCERT=$CERT/demoCA/cacert.pem

export PGSSLKEY=$CERT/client.key
export PGSSLCERT=$CERT/client.crt
' > client_env

source client_env

# 设置服务端参数
gs_guc set -D $GAUSSHOME/data -c "ssl=on"
gs_guc set -D $GAUSSHOME/data -c "ssl_ciphers = 'ALL'"
gs_guc set -D $GAUSSHOME/data -c "ssl_ca_file = '$CERT/demoCA/cacert.pem'"
gs_guc set -D $GAUSSHOME/data -c "ssl_key_file='$CERT/server.key'"
gs_guc set -D $GAUSSHOME/data -c "ssl_cert_file='$CERT/server.crt'"

# 重启数据库

vsql -d postgres -c " CREATE USER u1 PASSWORD 'u1.password' "

# 连接数据库：需加-h参数
vsql -h localhost -d postgres -U u1 -W 'u1.password' -r

rm -f client.* server.*
gs_guc set -D $GAUSSHOME/data -c "ssl_ciphers = 'ECDHE-ECDSA-SM4-CBC-SM3'"

openssl ecparam -name SM2 -genkey -out ./demoCA/private/cakey.pem
openssl req -new -key ./demoCA/private/cakey.pem -out ./demoCA/private/ca_cert_req.pem -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=root"
openssl x509 -req -in ./demoCA/private/ca_cert_req.pem -days 7300 -signkey ./demoCA/private/cakey.pem -out ./demoCA/cacert.pem

# server
openssl ecparam -name SM2 -genkey -out server.key
openssl req -new -key server.key -out server.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=server"
openssl x509 -req -in server.csr -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -CAcreateserial -out server.crt

# client
openssl ecparam -name SM2 -genkey -out client.key
openssl req -new -key client.key -out client.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=client"
openssl x509 -req -in client.csr -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -CAcreateserial -out client.crt

chmod 600 client.key client.crt server.key server.crt ./demoCA/cacert.pem

openssl x509 -in client.crt -text

国密

mkdir cert
cd cert

openssl version
# OpenSSL 1.1.1s Tassl 2.1.2 1 Nov 2022

cp ../tassl/install/openssl.cnf ./
chmod +w ./openssl.cnf

echo '
[ gm_ca_cert ]
subjectKeyIdentifier=hash
authorityKeyIdentifier=keyid:always,issuer
basicConstraints = critical,CA:true
keyUsage = critical, cRLSign, keyCertSign

[ gm_sign_cert ]
basicConstraints = CA:FALSE
keyUsage = critical, digitalSignature, nonRepudiation

[ gm_enc_cert ]
basicConstraints = CA:FALSE
keyUsage = critical, keyEncipherment, dataEncipherment, keyAgreement' >> ./openssl.cnf

mkdir ./demoCA ./demoCA/newcerts ./demoCA/private
chmod 700 ./demoCA/private
echo '01'>./demoCA/serial
touch ./demoCA/index.txt

# ca
openssl ecparam -name SM2 -genkey -out ./demoCA/private/cakey.pem
openssl req -config openssl.cnf -new -key ./demoCA/private/cakey.pem -sm3 -out ./demoCA/private/ca_cert_req.pem -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=root"
openssl x509 -req -extfile openssl.cnf -extensions gm_ca_cert -in ./demoCA/private/ca_cert_req.pem -sm3 -days 7300 -signkey ./demoCA/private/cakey.pem -out ./demoCA/cacert.pem

# server
openssl ecparam -name SM2 -genkey -out server.key
openssl ec -in server.key -passout pass:gauss@123 -sm4 -out server.key
openssl req -config openssl.cnf -new -key server.key -passin pass:gauss@123 -sm3 -out server.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=server"
openssl x509 -req -extfile openssl.cnf -extensions gm_sign_cert -in server.csr -sm3 -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -passin pass:gauss@123 -CAcreateserial -out server.crt

# server.enc
openssl ecparam -name SM2 -genkey -out server_enc.key
openssl ec -in server_enc.key -passout pass:gauss@123 -sm4 -out server_enc.key
openssl req -config openssl.cnf -new -key server_enc.key -passin pass:gauss@123 -sm3 -out server_enc.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=server"
openssl x509 -req -extfile openssl.cnf -extensions gm_enc_cert -in server_enc.csr -sm3 -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -passin pass:gauss@123 -CAcreateserial -out server_enc.crt

gs_guc encrypt -M server -D ./ -K gauss@123

# client
openssl ecparam -name SM2 -genkey -out client.key
openssl ec -in client.key -passout pass:gauss@123 -sm4 -out client.key
openssl req -config openssl.cnf -new -key client.key -passin pass:gauss@123 -sm3 -out client.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=client"
openssl x509 -req -extfile openssl.cnf -extensions gm_sign_cert -in client.csr -sm3 -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -passin pass:gauss@123 -CAcreateserial -out client.crt

# client.enc
openssl ecparam -name SM2 -genkey -out client_enc.key
openssl ec -in client_enc.key -passout pass:gauss@123 -sm4 -out client_enc.key
openssl req -config openssl.cnf -new -key client_enc.key -passin pass:gauss@123 -sm3 -out client_enc.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=client"
openssl x509 -req -extfile openssl.cnf -extensions gm_enc_cert -in client_enc.csr -sm3 -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -passin pass:gauss@123 -CAcreateserial -out client_enc.crt

gs_guc encrypt -M client -D ./ -K gauss@123

# openssl x509 -in client.crt -text

export CERT=`pwd`
echo '
export CERT=`pwd`
export PGSSLMODE=verify-ca
export PGSSLTLCP=1

export PGSSLROOTCERT=$CERT/demoCA/cacert.pem

export PGSSLKEY=$CERT/client.key
export PGSSLCERT=$CERT/client.crt
export PGSSLENCKEY=$CERT/client_enc.key
export PGSSLENCCERT=$CERT/client_enc.crt
' > client_env

source client_env

# 设置服务端参数
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl=on"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_ciphers = 'ALL'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_use_tlcp=on"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_ca_file = '$CERT/demoCA/cacert.pem'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_key_file='$CERT/server.key'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_cert_file='$CERT/server.crt'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_enc_key_file='$CERT/server_enc.key'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_enc_cert_file='$CERT/server_enc.crt'"

# 重启数据库

数据库安全全密态

Tue, 20 May 2025 18:22:00 +0800

PQconnectStart
 makeEmptyPGconn
 connectOptions1
 parse_connection_string
 fillPGconn
 conninfo_getval("enable_ce") # 解析 'enable_ce'
 connectDBStart
 PQconnectPoll
 if CONNECTION_NEEDED: # 建立TCP连接
 connect
 elif CONNECTION_MADE: # 发送连接参数
 pqBuildStartupPacket3
 build_startup_packet
 pqPacketSend
 elif CONNECTION_AWAITING_RESPONSE # 进行身份认证
 pg_fe_sendauth
PQexec
 PQexecStart
 PQsendQuery
 Processor::run_pre_query # 加密SQL语句中的数据
 Parser::Parse
 run_pre_statement
 run_pre_insert_statement
 CachedColumnManager::get_cached_columns
 RawValues::get_raw_values_from_insert_statement
 ValuesProcessor::process_values
 process_inside_value # 加密
 StatementData::replace_raw_values
 pqPutMsgStart
 pqPuts
 pqPutMsgEnd
 pqFlush
 PQexecFinish
 PQgetResult
 parseInput
 pqParseInput3
 pqGetc
 pqGetInt
 case 'D'
 getAnotherTuple
 pqRowProcessor
 ValuesProcessor::deprocess_value # 解密服务端返回的数据
 pqGets
 case 'Z'
 Processor::run_post_query
 pqReadData

vastbase 加密函数

Sun, 09 Feb 2025 16:10:00 +0800

1 需求背景

1.1 数据加密背景

加密的原理
不同场景中，适合的加密算法类型不同。对存储数据加密，通常采用对称密码算法，此处主要介绍对称密码算法：
- 加密原理：输入1个明文，输入1个密钥，对明文和密钥进行一些运算（比如异或，代换），可得到1个密文。密钥通常是随机生成的。
- 加密算法：DES算法，发布于1977年，已确定为不安全加密算法。3DES算法，调用3次DES算法，生成3个密钥，安全性与DES差别不大，也属于不安全的加密算法。AES算法，发布于2001年，通用的国际标准

数据库加密函数
几乎所有数据库，都提供内置加密函数，让用户通过SQL语句调用。最典型的场景如下：

-- 假设，数据库提供函数encrypt(明文，密钥，加密算法)，输出为密文
-- 用户想表't1'中存储数据'shenkun'，则存储的语法如下：（用户自己保管密钥）
INSERT INTO t1 VALUES (encrypt('shenkun', '一串随机的密钥', 'aes'));

1.2 oracle 加密包

早期版本的oracle中，包含1个名为dbms_obfuscation_toolkit的包，提供7个函数，主要实现加密、解密等功能：

版本信息：oracle 8i版本开始提供，oracle 10g版本开始不被推荐使用，由dbms_crypto代替，oracle 21c版本正式移除
函数列表：
- 生成随机数：desgetkey(seed) -> key
- 加密：desencrypt(input, key) -> encrypted_data
- 解密：descdecrypt(input, key) -> decrypted_data
- 生成随机数：des3getkey(which=>0, seed) -> key
- 加密：des3encrypt(input, key, which=>0, iv=>012345678abcdef) -> encrypted_data
- 解密：des3decrypt(input, key, which=>0, iv=>012345678abcdef) -> decrypted_data
- 哈希：md5(input) -> checksum
函数参数：函数参数有3种数据类型：varchar2, raw。与raw类型相比，如果是varchar2类型，参数名需加上_string后缀。比如，raw类型的入参名为input，则varcha2类型入参名为input_string
函数限制：
- desgetkey：seed长度最短为80字节
- desencrypt：input长度是8字节的整数倍；key最短为8字节，超过8字节的部分被丢弃
- descdecrypt：input长度是8字节的整数倍；key最短为8字节，超过8字节的部分被丢弃
- des3getkey: seed长度最短为80字节
- des3encrypt：input长度是8字节的整数倍；which为0时，key最短为16字节，超过16字节的部分被丢弃；which为1时，key最短为24字节，超过24字节的部分被丢弃
- des3dencrypt：input长度是8字节的整数倍；which为0时，key最短为16字节，超过16字节的部分被丢弃；which为1时，key最短为24字节，超过24字节的部分被丢弃
- md5：无
参考文档
- 函数介绍：函数背景、注意事项等：https://docs.oracle.com/cd/A97630_01/appdev.920/a96590/adgsec04.htm
- 函数参数：参数类型、调用示例等：https://docs.oracle.com/cd/B10500_01/appdev.920/a96612/d_obtoo2.htm

以下是上述函数的调用示例：

海量透明加密设计

Mon, 23 Mar 2026 20:52:00 +0800

1 透明加密

1.1 功能简述

关于透明加密的基本概念，请看需求文档。
用户使用透明加密的示例如下：

CREATE TABLE t1 (c1 TEXT, c2 TEXT);

CREATE ENCRYPTION KEY tde_key WITH (source=local, password='pass.123');
CREATE ENCRYPTION POLICY ep1 FRO t1 KEY tde_key;

INSERT INTO t1 VALUES ('data1', 'data2');
INSERT INTO t1 VALUES ('data1', 'data2');
SELECT * FROM t1;

1.2 实现方案

1.2.1 整体架构

透明加密的核心目标，是通过数据加密方案，解决攻击者绕过数据库安全机制，直接从磁盘窃取数据的问题。
在加密数据后，需要确保不影响内核在数据上进行计算。因此，需要在存储层底层，对数据进行加密。另外，为确保存储底层能够识别哪些数据加密，哪些数据不加密，以及使用什么算法加密等，上层需传递加密信息。透明加密逻辑架构如下：

1.2.2 工作流程

为适配存储底层设计，同时兼顾加密性能，以Page为粒度进行加密，并且，在Page中，存储加密信息。

1.2.3 详细流程

一、启动进程

在启动进程阶段，故障恢复时，如果回放到属于加密表的xlog，涉及到解密Page，因此，需在故障恢复前加载密钥。

main # 1. 启动数据库进程（基于pg-16代码）
 PostmasterMain # 2. 启动postmaster进程
 SelectConfigFiles # 3. 读取GUC文件
 'tde_load_encryption_key' # 4. 读取密钥文件（后文介绍密钥如何生成）
 SysLogger_Start
 StartupDataBase # 5. 开始故障恢复
 StartupProcessMain
 StartupXLOG
 ReadControlFile
 PerformWalRecovery
 for loop:
 ReadRecord # 6. 读取xlog
 ApplyWalRecord # 7. 重放xlog
 GetRmgr.rm_redo
 ...
 heap_xlog_insert
 XLogReadBufferForRedo
 XLogReadBufferForRedoExtended
 XLogReadBufferExtended
 ReadBufferWithoutRelcache
 ReadBuffer_common
 smgrread # 8. 读取数据文件
 # 需解密，后文统一介绍
 ServerLoop
 for loop:
 ConnCreate
 BackendStartup
 BackendRun
 PostgresMain # 9. 启动postgres进程
 StartCheckpointer
 StartBackgroundWriter
 StartChildProcess
 AuxiliaryProcessMain
 BackgroundWriterMain # 10. 启动bgwriter进程

二、生成密钥

当前版本，所有表，使用同一个数据密钥。因此，暂时无需新增系统表，存储密钥对象。

海量透明加密需求

Fri, 20 Mar 2026 10:47:00 +0800

1 简介

1.1 目的

透明加密特性提供数据加密功能，核心原理是在数据库将数据存储至磁盘时，先加密再存储。
本需求将从0设计透明加密特性，在保障功能、性能、易用性、可用性、可维护性、可扩展性等的前提下，让特性达到商用标准。

1.2 适用范围

Vastbase V5版本。

1.3 术语定义、首字母缩写词和缩略语

TDE：Transparent Data Encryption，透明数据加密，由数据库提供的数据加密特性

1.4 参考资料

oracle 透明加密特性：https://docs.oracle.com/en/database/oracle/oracle-database/26/dbtde/preface.html
sql server 透明加密特性：https://learn.microsoft.com/en-us/sql/relational-databases/security/encryption/transparent-data-encryption?view=sql-server-ver17
oceanbase 透明加密特性：https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000004475958
kingbase 透明加密特性：https://docs.kingbase.com.cn/cn/KES-V9R1C10/safe/transparent-data-Encyption
dm8 透明加密特性：https://eco.dameng.com/document/dm/zh-cn/pm/storage-encryption.html#7.1.1%20%E5%85%A8%E5%BA%93%E5%8A%A0%E5%AF%86
gaussdb 透明加密特性：https://support.huaweicloud.com/intl/zh-cn/fg-gaussdb-dist-v8/gaussdb-18-0019.html

2 透明加密

2.1 功能简述

一、基本原理

通常，用户将数据传输给数据库后，数据库将数据存储到磁盘。攻击者可能利用多种数据库内部或外部漏洞，例如操作系统漏洞等，绕过数据库安全机制，直接从磁盘读取数文件，窃取用户数据。

透明加密，是一种由数据库提供的加密特性，可有效解决攻击者从磁盘窃取数据的问题。开启透明加密后，数据库将数据存储到磁盘时，先加密数据，再存储数据密文；数据库从磁盘读取数据时，先解密数据密文，再进行其他计算。用户访问透明加密表时，包括存储、读取数据等，与访问普通表无任何区别，加密和解密过程由数据库自动完成，即对用户透明。

二、竞品分析

几乎所有商用关系数据库中，都支持透明加密特性，包括oracle, sql server, oceanbase, kingbase, dm8等，postgresql不支持透明加密特性。
使用透明加密时，通常包括3个阶段：

定义用于加密的密钥
使用SQL语法，定义哪些对象需加密，不同产品，定义加密对象的粒度不同
使用SQL语法，访问透明加密表，以及进行其他运维等操作

各产品中，定义加密对象的SQL语法如下：

-- 一、oracle
CREATE TABLE t1(c1 INT, c2 TEXT ENCRYPT);
CREATE TABLESPACE ts1 DATAFILE .. ENCRYPTION USING 'AES192' ENCRYPT;
-- 二、sql server
CREATE DATABASE ENCRYPTION KEY WITH ALGORITHM = AES_256 ..
ALTER DATABASE db1 SET ENCRYPTION ON;
-- 三、oceanbase
CREATE TABLESPACE ts1 encryption = 'y'; -- mysql cmpt
CREATE TABLESPACE ts1 ENCRYPTION USING 'aes-256'; -- oracle cmpt
-- 四、kingbase
CREATE TABLESPACE ts .. WITH (ENCRYPTION = TRUE);
CREATE TABLE ts .. ENCRYPTED BY 'this is a key';
-- 五、dm8
intdb .. ENCRYPT_NAME ..
CREATE TABLESPACE .. ENCRYPT WITH ..
CREATE TABLE t1 (c1 INT, c2 INT ENCRYPT WITH ..);
-- 六、gaussdb
CREATE TABLE t1 .. WITH (enable_tde=on);

各产品中，按定义加密对象的粒度，区别如下：

加密 on Kernel Notes

海量 1 用例 oracle加密函数

海量 1 设计 oracle加密函数

1

海量 1 需求 oracle加密函数

1 简介

1.1 目的

1.2 适用范围

1.3 术语定义、首字母缩写词和缩略语

1.3 参考资料

2 支持oracle加密插件dbms_obfuscation_toolkit

2.1 功能简述

一、基础知识

二、Oracle加密包

传统安全 1 密码学

1 密码学综述

2 密码算法

2.1 对称加密算法

传统安全 5 数据库加密

1 数据库加密的背景

1.1 数据库安全机制

1.2 数据泄露问题

1.3 数据库加密方案分类

一、按加密位置分类

二、按加密定义方式分类

海量 3 需求 pg_hba.conf加密

1 需求背景

2 需求分析

2.1 适配点

2.2 代码流程

数据库安全 0 postgresql表级透明加密

1 特性背景

2 实现方案

2.1 系统表

1. pg_key_info 密钥信息

2. pg_key_data 密钥数据

3. pg_encryption 加密对象

2.2 定义表

数据库安全 5 全密态

0 基础调研

一、运算符

数据库安全 9 透明加密

1 透明加密背景

2 透明加密使用

2.1 开启透明加密

2.2 定义加密表

2.3 验证数据加密

3 透明加密设计

4 透明加密原理

1 概述

1.1 模块

1 概述

1.1 功能

1.2 适配点

1.3 kun tde

2 调用关系

2.1 初始化数据页

PageInit

image

2.2 写入数据页

smgrextend

WAL 加密模块设计

1 威胁模型

1.1 为什么不用 dm-crypt 了事

1.2 FPI 是必须堵的洞

专利 全密态 索引

1 专利名称

2 技术背景

3 发明内容

4 附图及附图的简单说明

4.1 密态索引结构

4.2 密态索引插入流程

5 具体实施方式

5.1 创建密态索引

5.2 向索引插入1条数据

5.3 从索引中查找1条数据

高质量专项 全密态机密计算

目录

1 架构

1.1 整体架构

专利全密态索引

高质量专项全密态机密计算

数据库安全传输加密

数据库安全全密态

海量透明加密设计

海量透明加密需求