MySQL8-中文参考-三十四-

布客飞龙
66 阅读50分钟

MySQL8 中文参考（三十四）

原文：docs.oracle.com/javase/tutorial/reallybigindex.html

8.5.3 MySQL 企业数据脱敏和去标识化插件

原文：dev.mysql.com/doc/refman/8.0/en/data-masking-plugin.html

8.5.3.1 MySQL 企业数据脱敏和去标识化插件安装

8.5.3.2 使用 MySQL 企业数据脱敏和去标识化插件

8.5.3.3 MySQL 企业数据脱敏和去标识化插件功能参考

8.5.3.4 MySQL 企业数据脱敏和去标识化插件功能描述

MySQL 企业数据脱敏和去标识化基于一个实现这些元素的插件库：

  • 一个名为data_masking的服务器端插件。

  • 一组可加载的函数提供了一个 SQL 级别的 API，用于执行脱敏和去标识化操作。其中一些函数需要SUPER权限。

原文：dev.mysql.com/doc/refman/8.0/en/data-masking-plugin-installation.html

8.5.3.1 MySQL 企业数据脱敏和去标识化插件安装

本节描述了如何安装或卸载 MySQL 企业数据脱敏和去标识化，它是作为一个包含插件和几个可加载函数的插件库文件实现的。有关安装或卸载插件和可加载函数的一般信息，请参见 Section 7.6.1, “Installing and Uninstalling Plugins”和 Section 7.7.1, “Installing and Uninstalling Loadable Functions”。

要被服务器使用，插件库文件必须位于 MySQL 插件目录中（由plugin_dir系统变量命名的目录）。如有必要，在服务器启动时通过设置plugin_dir的值来配置插件目录位置。

插件库文件的基本名称是data_masking。文件名后缀因平台而异（例如，Unix 和类 Unix 系统使用.so，Windows 使用.dll）。

要安装 MySQL 企业数据脱敏和去标识化插件和函数，请使用INSTALL PLUGIN和CREATE FUNCTION语句，并根据需要调整平台的.so后缀：

INSTALL PLUGIN data_masking SONAME 'data_masking.so';
CREATE FUNCTION gen_blocklist RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION gen_dictionary RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION gen_dictionary_drop RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION gen_dictionary_load RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION gen_range RETURNS INTEGER
  SONAME 'data_masking.so';
CREATE FUNCTION gen_rnd_email RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION gen_rnd_pan RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION gen_rnd_ssn RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION gen_rnd_us_phone RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION mask_inner RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION mask_outer RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION mask_pan RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION mask_pan_relaxed RETURNS STRING
  SONAME 'data_masking.so';
CREATE FUNCTION mask_ssn RETURNS STRING
  SONAME 'data_masking.so';

如果插件和函数在复制源服务器上使用，则还需在所有副本服务器上安装它们，以避免复制问题。

一旦按照上述描述安装，插件和函数将保持安装状态，直到被卸载。要移除它们，请使用UNINSTALL PLUGIN和DROP FUNCTION语句：

UNINSTALL PLUGIN data_masking;
DROP FUNCTION gen_blocklist;
DROP FUNCTION gen_dictionary;
DROP FUNCTION gen_dictionary_drop;
DROP FUNCTION gen_dictionary_load;
DROP FUNCTION gen_range;
DROP FUNCTION gen_rnd_email;
DROP FUNCTION gen_rnd_pan;
DROP FUNCTION gen_rnd_ssn;
DROP FUNCTION gen_rnd_us_phone;
DROP FUNCTION mask_inner;
DROP FUNCTION mask_outer;
DROP FUNCTION mask_pan;
DROP FUNCTION mask_pan_relaxed;
DROP FUNCTION mask_ssn;

原文：dev.mysql.com/doc/refman/8.0/en/data-masking-plugin-usage.html

8.5.3.2 使用 MySQL 企业数据脱敏和去标识化插件

在使用 MySQL 企业数据脱敏和去标识化之前，请根据提供的说明安装它，详情请参阅第 8.5.3.1 节，“MySQL 企业数据脱敏和去标识化插件安装”。

要在应用程序中使用 MySQL 企业数据脱敏和去标识化，请调用适用于所需操作的函数。有关详细的函数描述，请参阅第 8.5.3.4 节，“MySQL 企业数据脱敏和去标识化插件函数描述”。本节演示如何使用这些函数执行一些代表性任务。首先概述可用函数，然后展示这些函数在实际环境中的使用示例：

  • 脱敏数据以删除识别特征

  • 生成具有特定特征的随机数据

  • 使用字典生成随机数据

  • 使用脱敏数据进行客户识别

  • 创建显示脱敏数据的视图

脱敏数据以删除识别特征

MySQL 提供通用脱敏函数，用于脱敏任意字符串，以及特定类型值的专用脱敏函数。

通用脱敏函数

mask_inner() 和 mask_outer() 是根据字符串内部位置脱敏任意字符串的通用函数：

  • mask_inner() 脱敏其字符串参数的内部，保留末尾未脱敏。其他参数指定未脱敏末尾的大小。

    mysql> SELECT mask_inner('This is a string', 5, 1);
+--------------------------------------+
| mask_inner('This is a string', 5, 1) |
+--------------------------------------+
| This XXXXXXXXXXg                     |
+--------------------------------------+
mysql> SELECT mask_inner('This is a string', 1, 5);
+--------------------------------------+
| mask_inner('This is a string', 1, 5) |
+--------------------------------------+
| TXXXXXXXXXXtring                     |
+--------------------------------------+

  • mask_outer() 做相反的操作，遮盖其字符串参数的末尾，保留内部不遮盖。其他参数指定了遮盖末尾的大小。

    mysql> SELECT mask_outer('This is a string', 5, 1);
+--------------------------------------+
| mask_outer('This is a string', 5, 1) |
+--------------------------------------+
| XXXXXis a strinX                     |
+--------------------------------------+
mysql> SELECT mask_outer('This is a string', 1, 5);
+--------------------------------------+
| mask_outer('This is a string', 1, 5) |
+--------------------------------------+
| Xhis is a sXXXXX                     |
+--------------------------------------+

默认情况下，mask_inner() 和 mask_outer() 使用'X'作为遮盖字符，但允许一个可选的遮盖字符参数：

mysql> SELECT mask_inner('This is a string', 5, 1, '*');
+-------------------------------------------+
| mask_inner('This is a string', 5, 1, '*') |
+-------------------------------------------+
| This **********g                          |
+-------------------------------------------+
mysql> SELECT mask_outer('This is a string', 5, 1, '#');
+-------------------------------------------+
| mask_outer('This is a string', 5, 1, '#') |
+-------------------------------------------+
| #####is a strin#                          |
+-------------------------------------------+
特殊用途的遮盖函数

其他遮盖函数期望一个表示特定类型值的字符串参数，并对其进行遮盖以消除识别特征。

注意

这里的示例使用返回适当类型值的随机值生成函数来提供函数参数。有关生成函数的更多信息，请参阅使用特定特征生成随机数据。

支付卡主帐号遮盖。 遮盖函数提供主帐号数字的严格和宽松遮盖。

  • mask_pan() 遮盖号码除最后四位外的所有内容：

    mysql> SELECT mask_pan(gen_rnd_pan());
+-------------------------+
| mask_pan(gen_rnd_pan()) |
+-------------------------+
| XXXXXXXXXXXX2461        |
+-------------------------+

  • mask_pan_relaxed() 类似，但不遮盖表示支付卡发行者的前六位数字：

    mysql> SELECT mask_pan_relaxed(gen_rnd_pan());
+---------------------------------+
| mask_pan_relaxed(gen_rnd_pan()) |
+---------------------------------+
| 770630XXXXXX0807                |
+---------------------------------+

美国社会安全号码遮盖。 mask_ssn() 遮盖号码除最后四位外的所有内容：

mysql> SELECT mask_ssn(gen_rnd_ssn());
+-------------------------+
| mask_ssn(gen_rnd_ssn()) |
+-------------------------+
| XXX-XX-1723             |
+-------------------------+
使用特定特征生成随机数据

几个函数生成随机值。这些值可用于测试、模拟等用途。

gen_range() 返回从给定范围中选择的随机整数：

mysql> SELECT gen_range(1, 10);
+------------------+
| gen_range(1, 10) |
+------------------+
|                6 |
+------------------+

gen_rnd_email() 返回一个在example.com域中的随机电子邮件地址：

mysql> SELECT gen_rnd_email();
+---------------------------+
| gen_rnd_email()           |
+---------------------------+
| ayxnq.xmkpvvy@example.com |
+---------------------------+

gen_rnd_pan() 返回一个随机的支付卡主帐号数字：

mysql> SELECT gen_rnd_pan();

（gen_rnd_pan() 函数的结果未显示，因为其返回值仅应用于测试目的，而不用于发布。不能保证该号码未分配给合法支付帐户。）

gen_rnd_ssn() 返回一个随机的美国社会安全号码，第一部分和第二部分分别从未用于合法号码的范围中选择：

mysql> SELECT gen_rnd_ssn();
+---------------+
| gen_rnd_ssn() |
+---------------+
| 912-45-1615   |
+---------------+

gen_rnd_us_phone() 返回一个在未用于合法号码的 555 区号中的随机美国电话号码：

mysql> SELECT gen_rnd_us_phone();
+--------------------+
| gen_rnd_us_phone() |
+--------------------+
| 1-555-747-5627     |
+--------------------+
使用字典生成随机数据

MySQL 企业数据蒙面和去标识化使得可以将字典用作随机值的来源。要使用字典，必须首先从文件加载它并赋予一个名称。每个加载的字典都成为字典注册表的一部分。然后可以从注册的字典中选择项目并用作随机值或替换其他值。

有效的字典文件具有以下特征：

  • 文件内容为纯文本，每行一个术语。

  • 空行将被忽略。

  • 文件必须至少包含一个术语。

假设名为de_cities.txt的文件包含德国这些城市名称：

Berlin
Munich
Bremen

还假设名为us_cities.txt的文件包含美国这些城市名称：

Chicago
Houston
Phoenix
El Paso
Detroit

假设secure_file_priv系统变量设置为/usr/local/mysql/mysql-files。在这种情况下，将字典文件复制到该目录，以便 MySQL 服务器可以访问它们。然后使用gen_dictionary_load()加载字典到字典注册表并分配名称：

mysql> SELECT gen_dictionary_load('/usr/local/mysql/mysql-files/de_cities.txt', 'DE_Cities');
+--------------------------------------------------------------------------------+
| gen_dictionary_load('/usr/local/mysql/mysql-files/de_cities.txt', 'DE_Cities') |
+--------------------------------------------------------------------------------+
| Dictionary load success                                                        |
+--------------------------------------------------------------------------------+
mysql> SELECT gen_dictionary_load('/usr/local/mysql/mysql-files/us_cities.txt', 'US_Cities');
+--------------------------------------------------------------------------------+
| gen_dictionary_load('/usr/local/mysql/mysql-files/us_cities.txt', 'US_Cities') |
+--------------------------------------------------------------------------------+
| Dictionary load success                                                        |
+--------------------------------------------------------------------------------+

要从字典中选择一个随机术语，请使用gen_dictionary()：

mysql> SELECT gen_dictionary('DE_Cities');
+-----------------------------+
| gen_dictionary('DE_Cities') |
+-----------------------------+
| Berlin                      |
+-----------------------------+
mysql> SELECT gen_dictionary('US_Cities');
+-----------------------------+
| gen_dictionary('US_Cities') |
+-----------------------------+
| Phoenix                     |
+-----------------------------+

要从多个字典中选择一个随机术语，随机选择其中一个字典，然后从中选择���个术语：

mysql> SELECT gen_dictionary(ELT(gen_range(1,2), 'DE_Cities', 'US_Cities'));
+---------------------------------------------------------------+
| gen_dictionary(ELT(gen_range(1,2), 'DE_Cities', 'US_Cities')) |
+---------------------------------------------------------------+
| Detroit                                                       |
+---------------------------------------------------------------+
mysql> SELECT gen_dictionary(ELT(gen_range(1,2), 'DE_Cities', 'US_Cities'));
+---------------------------------------------------------------+
| gen_dictionary(ELT(gen_range(1,2), 'DE_Cities', 'US_Cities')) |
+---------------------------------------------------------------+
| Bremen                                                        |
+---------------------------------------------------------------+

gen_blocklist()函数使得可以用另一个字典中的术语替换一个字典中的术语，从而通过替换实现蒙面。它的参数是要替换的术语，术语出现的字典，以及要选择替换的字典。例如，要用美国城市替换德国城市，或者反之，可以像这样使用gen_blocklist()：

mysql> SELECT gen_blocklist('Munich', 'DE_Cities', 'US_Cities');
+---------------------------------------------------+
| gen_blocklist('Munich', 'DE_Cities', 'US_Cities') |
+---------------------------------------------------+
| Houston                                           |
+---------------------------------------------------+
mysql> SELECT gen_blocklist('El Paso', 'US_Cities', 'DE_Cities');
+----------------------------------------------------+
| gen_blocklist('El Paso', 'US_Cities', 'DE_Cities') |
+----------------------------------------------------+
| Bremen                                             |
+----------------------------------------------------+

如果要替换的术语不在第一个字典中，gen_blocklist()将不做任何更改返回它：

mysql> SELECT gen_blocklist('Moscow', 'DE_Cities', 'US_Cities');
+---------------------------------------------------+
| gen_blocklist('Moscow', 'DE_Cities', 'US_Cities') |
+---------------------------------------------------+
| Moscow                                            |
+---------------------------------------------------+
使用蒙面数据进行客户识别

在客户服务呼叫中心，一个常见的身份验证技术是要求客户提供他们社会安全号码（SSN）的最后四位数字。例如，一个客户可能说她的名字是乔安娜邦德，她的最后四位 SSN 数字是0007。

假设包含客户记录的customer表具有以下列：

  • id：客户 ID 号码。

  • first_name：客户名字。

  • last_name：客户姓氏。

  • ssn：客户社会安全号码。

例如，表可以定义如下：

CREATE TABLE customer
(
  id         BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
  first_name VARCHAR(40),
  last_name  VARCHAR(40),
  ssn        VARCHAR(11)
);

由客户服务代表使用的应用程序检查客户社会安全号码可能执行类似这样的查询：

mysql> SELECT id, ssn
mysql> FROM customer
mysql> WHERE first_name = 'Joanna' AND last_name = 'Bond';
+-----+-------------+
| id  | ssn         |
+-----+-------------+
| 786 | 906-39-0007 |
+-----+-------------+

然而，这会将社会安全号码暴露给客户服务代表，他们没有必要看到除最后四位数字之外的任何内容。相反，应用程序可以使用此查询仅显示蒙面的社会安全号码：

mysql> SELECT id, mask_ssn(CONVERT(ssn USING binary)) AS masked_ssn
mysql> FROM customer
mysql> WHERE first_name = 'Joanna' AND last_name = 'Bond';
+-----+-------------+
| id  | masked_ssn  |
+-----+-------------+
| 786 | XXX-XX-0007 |
+-----+-------------+

现在代表只能看到必要的内容，客户隐私得到保护。

为什么在mask_ssn()的参数中使用了CONVERT()函数？因为mask_ssn()需要一个长度为 11 的参数。因此，即使ssn被定义为VARCHAR(11)，如果ssn列具有多字节字符集，当传递给可加载函数时，它可能看起来比 11 个字节长，从而导致错误。将值转换为二进制字符串可以确保函数看到一个长度为 11 的参数。

当字符串参数没有单字节字符集时，可能需要类似的技术来处理其他数据掩码函数。

创建显示掩码数据的视图

如果来自表的掩码数据用于多个查询，定义一个生成掩码数据的视图可能会更方便。这样，应用程序可以从视图中选择，而无需在单个查询中执行掩码操作。

例如，可以像这样定义前一节中customer表的掩码视图：

CREATE VIEW masked_customer AS
SELECT id, first_name, last_name,
mask_ssn(CONVERT(ssn USING binary)) AS masked_ssn
FROM customer;

查询客户信息的操作变得更简单，但仍返回掩码数据：

mysql> SELECT id, masked_ssn
mysql> FROM masked_customer
mysql> WHERE first_name = 'Joanna' AND last_name = 'Bond';
+-----+-------------+
| id  | masked_ssn  |
+-----+-------------+
| 786 | XXX-XX-0007 |
+-----+-------------+

原文：dev.mysql.com/doc/refman/8.0/en/data-masking-plugin-function-reference.html

8.5.3.3 MySQL 企业数据掩码和去识别插件函数参考

表 8.47 MySQL 企业数据掩码和去识别插件函数

名称描述引入废弃
gen_blacklist()执行字典术语替换8.0.23
gen_blocklist()执行字典术语替换8.0.23
gen_dictionary_drop()从注册表中删除字典
gen_dictionary_load()将字典加载到注册表中
gen_dictionary()从字典返回随机术语
gen_range()在范围内生成随机数
gen_rnd_email()生成随机电子邮件地址
gen_rnd_pan()生成随机支付卡主帐号
gen_rnd_ssn()生成随机美国社会安全号码
gen_rnd_us_phone()生成随机美国电话号码
mask_inner()掩盖字符串的内部部分
mask_outer()掩盖字符串的左右部分
mask_pan()掩盖字符串的支付卡主帐号部分
mask_pan_relaxed()掩盖字符串的支付卡主帐号部分
mask_ssn()掩盖美国社会安全号码
名称描述引入废弃

原文：dev.mysql.com/doc/refman/8.0/en/data-masking-plugin-functions.html

8.5.3.4 MySQL 企业数据脱敏和去标识化插件函数描述

MySQL 企业数据脱敏和去标识化插件库包括多个函数，可分为以下类别：

  • 数据脱敏插件函数

  • 随机数据生成插件函数

  • 随机数据基于字典的插件函数

从 MySQL 8.0.19 开始，这些函数支持单字节latin1字符集用于字符串参数和返回值。在 MySQL 8.0.19 之前，这些函数将字符串参数视为二进制字符串（这意味着它们不区分大小写），并且字符串返回值为二进制字符串。您可以通过以下方式查看返回值字符集的差异：

MySQL 8.0.19 及更高版本：

mysql> SELECT CHARSET(gen_rnd_email());
+--------------------------+
| CHARSET(gen_rnd_email()) |
+--------------------------+
| latin1                   |
+--------------------------+

MySQL 8.0.19 之前：

mysql> SELECT CHARSET(gen_rnd_email());
+--------------------------+
| CHARSET(gen_rnd_email()) |
+--------------------------+
| binary                   |
+--------------------------+

对于任何版本，如果字符串返回值应该使用不同的字符集，请进行转换。以下示例显示如何将gen_rnd_email()的结果转换为utf8mb4字符集：

SET @email = CONVERT(gen_rnd_email() USING utf8mb4);

要明确生成二进制字符串（例如，生成 MySQL 8.0.19 之前版本的结果），请执行以下操作：

SET @email = CONVERT(gen_rnd_email() USING binary);

有时可能需要转换字符串参数，如使用脱敏数据进行客户识别中所示。

如果从mysql客户端内调用 MySQL 企业数据脱敏和去标识化函数，则二进制字符串结果将以十六进制表示，具体取决于--binary-as-hex的值。有关该选项的更多信息，请参见第 6.5.1 节，“mysql — MySQL 命令行客户端”。

数据脱敏插件函数

本节中的每个插件函数都对其字符串参数执行脱敏操作并返回脱敏结果。

  • mask_inner(*str*, *margin1*, *margin2* [, *mask_char*])

    脱敏字符串的内部部分，保留末尾不变，并返回结果。可以指定可选的脱敏字符。

    参数：

    • str: 需要脱敏的字符串。

    • margin1：非负整数，指定要保留未掩码的字符串左端字符数。如果值为 0，则不保留左端字符未掩码。

    • margin2：非负整数，指定要保留未掩码的字符串右端字符数。如果值为 0，则不保留右端字符未掩码。

    • mask_char：（可选）用于掩码的单个字符。如果未提供*mask_char*，默认为'X'。

      掩码字符必须是单字节字符。尝试使用多字节字符会产生错误。

    返回值：

    掩码字符串，如果任一边距为负则为NULL。

    如果边距值的总和大于参数长度，则不进行掩码，参数返回不变。

    示例：

    mysql> SELECT mask_inner('abcdef', 1, 2), mask_inner('abcdef',0, 5);
+----------------------------+---------------------------+
| mask_inner('abcdef', 1, 2) | mask_inner('abcdef',0, 5) |
+----------------------------+---------------------------+
| aXXXef                     | Xbcdef                    |
+----------------------------+---------------------------+
mysql> SELECT mask_inner('abcdef', 1, 2, '*'), mask_inner('abcdef',0, 5, '#');
+---------------------------------+--------------------------------+
| mask_inner('abcdef', 1, 2, '*') | mask_inner('abcdef',0, 5, '#') |
+---------------------------------+--------------------------------+
| a***ef                          | #bcdef                         |
+---------------------------------+--------------------------------+

  • mask_outer(*str*, *margin1*, *margin2* [, *mask_char*])

    掩盖字符串的左右端，保留内部未掩码，并返回结果。可以指定一个可选的掩码字符。

    参数：

    • str：要掩码的字符串。

    • margin1：非负整数，指定要掩码的字符串左端字符数。如果值为 0，则不掩盖左端字符。

    • margin2：非负整数，指定要掩码的字符串右端字符数。如果值为 0，则不掩盖右端字符。

    • mask_char：（可选）用于掩码的单个字符。如果未提供*mask_char*，默认为'X'。

      掩码字符必须是单字节字符。尝试使用多字节字符会产生错误。

    返回值：

    掩码字符串，如果任一边距为负则为NULL。

    如果边距值的总和大于参数长度，则整个参数将被掩码。

    示例：

    mysql> SELECT mask_outer('abcdef', 1, 2), mask_outer('abcdef',0, 5);
+----------------------------+---------------------------+
| mask_outer('abcdef', 1, 2) | mask_outer('abcdef',0, 5) |
+----------------------------+---------------------------+
| XbcdXX                     | aXXXXX                    |
+----------------------------+---------------------------+
mysql> SELECT mask_outer('abcdef', 1, 2, '*'), mask_outer('abcdef',0, 5, '#');
+---------------------------------+--------------------------------+
| mask_outer('abcdef', 1, 2, '*') | mask_outer('abcdef',0, 5, '#') |
+---------------------------------+--------------------------------+
| *bcd**                          | a#####                         |
+---------------------------------+--------------------------------+

  • mask_pan(*str*)

    掩码支付卡主帐号并返回除了最后四位以外的所有数字都替换为'X'字符的数字。

    参数：

    • str：要掩码的字符串。字符串必须适合主帐号的长度，但不进行其他检查。

    返回值：

    掩盖的支付号码作为字符串。如果参数长度不足，则返回不变。

    示例：

    mysql> SELECT mask_pan(gen_rnd_pan());
+-------------------------+
| mask_pan(gen_rnd_pan()) |
+-------------------------+
| XXXXXXXXXXXX9102        |
+-------------------------+
mysql> SELECT mask_pan(gen_rnd_pan(19));
+---------------------------+
| mask_pan(gen_rnd_pan(19)) |
+---------------------------+
| XXXXXXXXXXXXXXX8268       |
+---------------------------+
mysql> SELECT mask_pan('a*Z');
+-----------------+
| mask_pan('a*Z') |
+-----------------+
| a*Z             |
+-----------------+

  • mask_pan_relaxed(*str*)

    掩码支付卡主帐号并返回除了前六位和最后四位以外的所有数字都替换为'X'字符的数字。前六位数字表示支付卡发行者。

    参数：

    • str：要掩码的字符串。字符串必须适合主帐号的长度，但不进行其他检查。

    返回值：

    掩盖的支付号码作为字符串。如果参数长度不足，则返回不变。

    示例：

    mysql> SELECT mask_pan_relaxed(gen_rnd_pan());
+---------------------------------+
| mask_pan_relaxed(gen_rnd_pan()) |
+---------------------------------+
| 551279XXXXXX3108                |
+---------------------------------+
mysql> SELECT mask_pan_relaxed(gen_rnd_pan(19));
+-----------------------------------+
| mask_pan_relaxed(gen_rnd_pan(19)) |
+-----------------------------------+
| 462634XXXXXXXXX6739               |
+-----------------------------------+
mysql> SELECT mask_pan_relaxed('a*Z');
+-------------------------+
| mask_pan_relaxed('a*Z') |
+-------------------------+
| a*Z                     |
+-------------------------+

  • mask_ssn(*str*)

    掩码美国社会保障号码，并将除最后四位数字外的所有内容替换为'X'字符。

    参数：

    • str：要掩码的字符串。字符串必须是 11 个字符长。

    返回值：

    掩码的社会保障号码作为字符串，如果参数长度不正确则返回错误。

    示例：

    mysql> SELECT mask_ssn('909-63-6922'), mask_ssn('abcdefghijk');
+-------------------------+-------------------------+
| mask_ssn('909-63-6922') | mask_ssn('abcdefghijk') |
+-------------------------+-------------------------+
| XXX-XX-6922             | XXX-XX-hijk             |
+-------------------------+-------------------------+
mysql> SELECT mask_ssn('909');
ERROR 1123 (HY000): Can't initialize function 'mask_ssn'; MASK_SSN: Error:
String argument width too small
mysql> SELECT mask_ssn('123456789123456789');
ERROR 1123 (HY000): Can't initialize function 'mask_ssn'; MASK_SSN: Error:
String argument width too large
随机数据生成插件函数

本节中的插件函数会为不同类型的数据生成随机值。在可能的情况下，生成的值具有用于演示或测试值的特征，以避免将它们误认为是合法数据。例如，gen_rnd_us_phone() 返回一个使用未分配给实际使用电话号码的 555 区号的美国电话号码。各个函数描述会说明此原则的任何例外情况。

  • gen_range(*lower*, *upper*)

    生成从指定范围中选择的随机数。

    参数：

    • lower：指定范围下限的整数。

    • upper：指定范围上限的整数，必须不小于下限。

    返回值：

    一个在从*lower到upper（包括）范围内的随机整数，如果upper参数小于lower*则返回NULL。

    示例：

    mysql> SELECT gen_range(100, 200), gen_range(-1000, -800);
+---------------------+------------------------+
| gen_range(100, 200) | gen_range(-1000, -800) |
+---------------------+------------------------+
|                 177 |                   -917 |
+---------------------+------------------------+
mysql> SELECT gen_range(1, 0);
+-----------------+
| gen_range(1, 0) |
+-----------------+
|            NULL |
+-----------------+

  • gen_rnd_email()

    生成example.com域中的随机电子邮件地址。

    参数：

    无。

    返回值：

    作为字符串的随机电子邮件地址。

    示例：

    mysql> SELECT gen_rnd_email();
+---------------------------+
| gen_rnd_email()           |
+---------------------------+
| ijocv.mwvhhuf@example.com |
+---------------------------+

  • gen_rnd_pan([*size*])

    生成随机支付卡主帐号。该号码通过 Luhn 检查（执行校验和验证以对抗检查位的算法）。

    警告

    从gen_rnd_pan()返回的值仅应用于测试目的，不适合发布。无法保证给定的返回值未分配给合法支付账户。如果需要发布gen_rnd_pan()结果，请考虑使用mask_pan()或mask_pan_relaxed()进行掩码处理。

    参数：

    • size：（可选）指定结果大小的整数。如果未给出*size，则默认为 16。如果给出，size*必须是 12 到 19 范围内的整数。

    返回值：

    作为字符串的随机支付号码，如果给定超出允许范围的*size*参数，则返回NULL。

    示例：

    mysql> SELECT mask_pan(gen_rnd_pan());
+-------------------------+
| mask_pan(gen_rnd_pan()) |
+-------------------------+
| XXXXXXXXXXXX5805        |
+-------------------------+
mysql> SELECT mask_pan(gen_rnd_pan(19));
+---------------------------+
| mask_pan(gen_rnd_pan(19)) |
+---------------------------+
| XXXXXXXXXXXXXXX5067       |
+---------------------------+
mysql> SELECT mask_pan_relaxed(gen_rnd_pan());
+---------------------------------+
| mask_pan_relaxed(gen_rnd_pan()) |
+---------------------------------+
| 398403XXXXXX9547                |
+---------------------------------+
mysql> SELECT mask_pan_relaxed(gen_rnd_pan(19));
+-----------------------------------+
| mask_pan_relaxed(gen_rnd_pan(19)) |
+-----------------------------------+
| 578416XXXXXXXXX6509               |
+-----------------------------------+
mysql> SELECT gen_rnd_pan(11), gen_rnd_pan(20);
+-----------------+-----------------+
| gen_rnd_pan(11) | gen_rnd_pan(20) |
+-----------------+-----------------+
| NULL            | NULL            |
+-----------------+-----------------+

  • gen_rnd_ssn()

    以*AAA*-*BB*-*CCCC*格式生成一个随机的美国社会安全号码。*AAA部分大于 900，BB*部分小于 70，这些特征不用于合法的社会安全号码。

    参数：

    无。

    返回值：

    一个随机的社会安全号码作为一个字符串。

    示例：

    mysql> SELECT gen_rnd_ssn();
+---------------+
| gen_rnd_ssn() |
+---------------+
| 951-26-0058   |
+---------------+

  • gen_rnd_us_phone()

    以1-555-*AAA*-*BBBB*格式生成一个随机的美国电话号码。555 区号不用于合法的电话号码。

    参数：

    无。

    返回值：

    一个随机的美国电话号码作为一个字符串。

    示例：

    mysql> SELECT gen_rnd_us_phone();
+--------------------+
| gen_rnd_us_phone() |
+--------------------+
| 1-555-682-5423     |
+--------------------+
基于随机数据字典的插件函数

本节中的插件函数操作术语字典，并根据它们执行生成和掩盖操作。其中一些函数需要SUPER权限。

当加载字典时，它成为字典注册表的一部分，并被分配一个名称供其他字典函数使用。字典是从包含每行一个术语的纯文本文件中加载的。空行将被忽略。为了有效，字典文件必须至少包含一行非空行。

  • gen_blacklist(*str*, *dictionary_name*, *replacement_dictionary_name*)

    用第二个字典中的术语替换第一个字典中存在的术语，并返回替换术语。这通过替换掩盖了原始术语。此函数在 MySQL 8.0.23 中已弃用；请改用gen_blocklist()。

  • gen_blocklist(*str*, *dictionary_name*, *replacement_dictionary_name*)

    用第二个字典中的术语替换第一个字典中存在的术语，并返回替换术语。这通过替换掩盖了原始术语。此函数在 MySQL 8.0.23 中添加；请改用gen_blacklist()。

    参数：

    • str：指示要替换的术语的字符串。

    • dictionary_name：命名包含要替换的术语的字典的字符串。

    • replacement_dictionary_name：命名要选择替换术语的字典的字符串。

    返回值：

    从*replacement_dictionary_name中随机选择的字符串作为str的替换，如果它不在dictionary_name中，则为str*，如果任一字典名称不在字典注册表中，则为NULL。

    如果要替换的术语出现在两个字典中，返回值可能是相同的术语。

    示例：

    mysql> SELECT gen_blocklist('Berlin', 'DE_Cities', 'US_Cities');
+---------------------------------------------------+
| gen_blocklist('Berlin', 'DE_Cities', 'US_Cities') |
+---------------------------------------------------+
| Phoenix                                           |
+---------------------------------------------------+

  • gen_dictionary(*dictionary_name*)

    从字典中返回一个随机术语。

    参数：

    • dictionary_name：命名要选择术语的字典的字符串。

    返回值：

    从字典中随机选择一个术语作为字符串，如果字典名称不在字典注册表中，则返回NULL。

    示例：

    mysql> SELECT gen_dictionary('mydict');
+--------------------------+
| gen_dictionary('mydict') |
+--------------------------+
| My term                  |
+--------------------------+
mysql> SELECT gen_dictionary('no-such-dict');
+--------------------------------+
| gen_dictionary('no-such-dict') |
+--------------------------------+
| NULL                           |
+--------------------------------+

  • gen_dictionary_drop(*dictionary_name*)

    从字典注册表中移除一个字典。

    此函数需要SUPER权限。

    参数：

    • dictionary_name：一个字符串，用于指定要从字典注册表中移除的字典的名称。

    返回值：

    一个指示删除操作是否成功的字符串。Dictionary removed表示成功。Dictionary removal error表示失败。

    示例：

    mysql> SELECT gen_dictionary_drop('mydict');
+-------------------------------+
| gen_dictionary_drop('mydict') |
+-------------------------------+
| Dictionary removed            |
+-------------------------------+
mysql> SELECT gen_dictionary_drop('no-such-dict');
+-------------------------------------+
| gen_dictionary_drop('no-such-dict') |
+-------------------------------------+
| Dictionary removal error            |
+-------------------------------------+

  • gen_dictionary_load(*dictionary_path*, *dictionary_name*)

    将文件加载到字典注册表中，并为字典分配一个名称，以便在其他需要字典名称参数的函数中使用。

    此函数需要SUPER权限。

    重要提示

    字典不是持久的。应用程序使用的任何字典都必须在每次服务器启动时加载。

    一旦加载到注册表中，字典将按原样使用，即使底层字典文件发生更改。要重新加载字典，首先使用gen_dictionary_drop()将其删除，然后再次使用gen_dictionary_load()加载。

    参数：

    • dictionary_path：一个字符串，指定字典文件的路径名。

    • dictionary_name：一个字符串，为字典提供名称。

    返回值：

    一个指示加载操作是否成功的字符串。Dictionary load success表示成功。Dictionary load error表示失败。字典加载失败可能出现多种原因，包括：

    • 已加载具有给定名称的字典。

    • 未找到字典文件。

    • 字典文件不包含任何术语。

    • secure_file_priv系统变量已设置，但字典文件未位于该变量指定的目录中。

    示例：

    mysql> SELECT gen_dictionary_load('/usr/local/mysql/mysql-files/mydict','mydict');
+---------------------------------------------------------------------+
| gen_dictionary_load('/usr/local/mysql/mysql-files/mydict','mydict') |
+---------------------------------------------------------------------+
| Dictionary load success                                             |
+---------------------------------------------------------------------+
mysql> SELECT gen_dictionary_load('/dev/null','null');
+-----------------------------------------+
| gen_dictionary_load('/dev/null','null') |
+-----------------------------------------+
| Dictionary load error                   |
+-----------------------------------------+

8.6 MySQL 企业加密

原文：dev.mysql.com/doc/refman/8.0/en/enterprise-encryption.html

8.6.1 MySQL 企业加密安装和升级

8.6.2 配置 MySQL 企业加密

8.6.3 MySQL 企业加密用法和示例

8.6.4 MySQL 企业加密功能参考

8.6.5 MySQL 企业加密组件功能描述

8.6.6 MySQL 企业加密传统功能描述

注意

MySQL 企业加密是 MySQL 企业版中包含的扩展，这是一个商业产品。要了解更多关于商业产品的信息，请访问www.mysql.com/products/。

MySQL 企业版包括一组加密函数，这些函数在 SQL 级别暴露了 OpenSSL 的功能。这些函数使企业应用程序能够执行以下操作：

  • 使用公钥非对称加密实现额外的数据保护

  • 创建公钥、私钥和数字签名

  • 执行非对称加密和解密

  • 使用加密哈希进行数字签名和数据验证和验证

在 MySQL 8.0.30 之前的版本中，这些功能基于openssl_udf共享库。从 MySQL 8.0.30 开始，它们由 MySQL 组件component_enterprise_encryption提供。

8.6.1 MySQL Enterprise Encryption 安装和升级

原文：dev.mysql.com/doc/refman/8.0/en/enterprise-encryption-installation.html

在 MySQL 8.0.30 之前的版本中，MySQL Enterprise Encryption 提供的函数是通过单独创建它们而安装的，基于openssl_udf共享库。从 MySQL 8.0.30 开始，这些函数由 MySQL 组件component_enterprise_encryption提供，安装组件会安装所有函数。从该版本开始，openssl_udf共享库中的函数已被弃用，您应该升级到组件。

  • 从 MySQL 8.0.30 安装

  • 到 MySQL 8.0.29 安装

  • 升级 MySQL Enterprise Encryption

从 MySQL 8.0.30 安装

从 MySQL 8.0.30 开始，MySQL Enterprise Encryption 的函数由 MySQL 组件component_enterprise_encryption提供，而不是从openssl_udf共享库安装。如果您正在从早期版本升级到 MySQL 8.0.30，其中使用了 MySQL Enterprise Encryption，您创建的函数仍然可用并受支持。但是，这些旧版函数从此版本开始已被弃用，建议您安装组件。组件函数向后兼容。有关升级信息，请参见升级 MySQL Enterprise Encryption。

如果您正在升级，在安装组件之前，请使用DROP FUNCTION语句卸载旧版函数：

DROP FUNCTION asymmetric_decrypt;
DROP FUNCTION asymmetric_derive;
DROP FUNCTION asymmetric_encrypt;
DROP FUNCTION asymmetric_sign;
DROP FUNCTION asymmetric_verify;
DROP FUNCTION create_asymmetric_priv_key;
DROP FUNCTION create_asymmetric_pub_key;
DROP FUNCTION create_dh_parameters;
DROP FUNCTION create_digest;

函数名称必须以小写指定。这些语句需要对mysql数据库的DROP权限。

要安装组件，请发出一个INSTALL COMPONENT语句：

INSTALL COMPONENT "file://component_enterprise_encryption";

INSTALL COMPONENT需要mysql.component系统表的INSERT权限，因为它会向该表添加一行以注册组件。要验证组件是否已安装，请发出：

SELECT * FROM mysql.component;

在mysql.component中列出的组件在启动序列期间由加载器服务加载。

如果您需要卸载组件，请发出一个UNINSTALL COMPONENT语句：

UNINSTALL COMPONENT "file://component_enterprise_encryption";

查看更多详细信息，请参见第 7.5.1 节，“安装和卸载组件”。

安装组件会安装所有函数，因此您无需像在 MySQL 8.0.30 之前那样使用CREATE FUNCTION语句创建它们。卸载组件会卸载所有函数。

安装组件后，如果您希望组件函数支持解密和验证在 MySQL 8.0.30 之前生成的遗留函数产生的内容，请将组件的系统变量enterprise_encryption.rsa_support_legacy_padding设置为ON。此外，如果您希望更改组件函数生成的 RSA 密钥的最大长度允许值，请使用组件的系统变量enterprise_encryption.maximum_rsa_key_size设置一个适当的最大值。有关配置信息，请参见第 8.6.2 节，“配置 MySQL 企业加密”。

安装到 MySQL 8.0.29

在 MySQL 8.0.29 之前，MySQL 企业加密函数位于安装在插件目录（由plugin_dir系统变量命名的目录）中的可加载函数库文件中。函数库基本名称为openssl_udf，后缀取决于平台。例如，在 Linux 或 Windows 上的文件名分别为openssl_udf.so或openssl_udf.dll。

要从openssl_udf共享库文件安装函数，请使用CREATE FUNCTION语句。要从库中加载所有函数，请使用以下一组语句，根据需要调整文件名后缀：

CREATE FUNCTION asymmetric_decrypt RETURNS STRING
  SONAME 'openssl_udf.so';
CREATE FUNCTION asymmetric_derive RETURNS STRING
  SONAME 'openssl_udf.so';
CREATE FUNCTION asymmetric_encrypt RETURNS STRING
  SONAME 'openssl_udf.so';
CREATE FUNCTION asymmetric_sign RETURNS STRING
  SONAME 'openssl_udf.so';
CREATE FUNCTION asymmetric_verify RETURNS INTEGER
  SONAME 'openssl_udf.so';
CREATE FUNCTION create_asymmetric_priv_key RETURNS STRING
  SONAME 'openssl_udf.so';
CREATE FUNCTION create_asymmetric_pub_key RETURNS STRING
  SONAME 'openssl_udf.so';
CREATE FUNCTION create_dh_parameters RETURNS STRING
  SONAME 'openssl_udf.so';
CREATE FUNCTION create_digest RETURNS STRING
  SONAME 'openssl_udf.so';

安装后，函数将在服务器重新启动时保持安装状态。如果需要卸载函数，请使用DROP FUNCTION语句：

DROP FUNCTION asymmetric_decrypt;
DROP FUNCTION asymmetric_derive;
DROP FUNCTION asymmetric_encrypt;
DROP FUNCTION asymmetric_sign;
DROP FUNCTION asymmetric_verify;
DROP FUNCTION create_asymmetric_priv_key;
DROP FUNCTION create_asymmetric_pub_key;
DROP FUNCTION create_dh_parameters;
DROP FUNCTION create_digest;

在CREATE FUNCTION和DROP FUNCTION语句中，函数名称必须以小写指定。这与在函数调用时使用的方式不同，对于函数调用时，您可以使用任何大小写。

CREATE FUNCTION和DROP FUNCTION语句分别需要mysql数据库的INSERT和DROP权限。

openssl_udf共享库提供的函数允许最小密钥大小为 1024 位。您可以使用MYSQL_OPENSSL_UDF_RSA_BITS_THRESHOLD、MYSQL_OPENSSL_UDF_DSA_BITS_THRESHOLD和MYSQL_OPENSSL_UDF_DH_BITS_THRESHOLD环境变量设置最大密钥大小，如第 8.6.2 节，“配置 MySQL 企业加密”中所述。如果不设置最大密钥大小，RSA 算法的上限为 16384，DSA 算法的上限为 10000，由 OpenSSL 指定。

升级 MySQL 企业加密

如果您从使用openssl_udf共享库提供的函数的较早版本升级到 MySQL 8.0.30 或更高版本，则您创建的函数仍然可用并受支持。但是，这些传统函数从 MySQL 8.0.30 开始已被弃用，建议您安装 MySQL 企业加密组件component_enterprise_encryption。

在升级之前，在安装组件之前，您必须使用DROP FUNCTION语句卸载传统函数。有关如何执行此操作的说明，请参见从 MySQL 8.0.30 安装。

组件函数向后兼容：

  • RSA 公钥和私钥由传统函数生成，可以与组件函数一起使用。

  • 使用传统函数加密的数据可以由组件函数解密。

  • 由传统函数创建的签名可以使用组件函数进行验证。

为了使组件函数支持由传统函数生成的内容的解密和验证，您必须将系统变量enterprise_encryption.rsa_support_legacy_padding设置为ON（默认为OFF）。有关配置信息，请参见第 8.6.2 节，“配置 MySQL 企业加密”。

由于组件函数使用的填充和密钥格式与当前标准不同，传统函数无法处理由组件函数创建的加密数据、公钥和签名。

component_enterprise_encryption 组件提供的新函数在行为和支持方面与 openssl_udf 共享库提供的旧版函数有一些差异。其中最重要的是：

  • 旧版函数支持较旧的 DSA 算法和 Diffie-Hellman 密钥交换方法。组件函数仅使用普遍首选的 RSA 算法。

  • 对于旧版函数，最小 RSA 密钥大小低于当前最佳实践。组件函数遵循当前最佳实践的最小 RSA 密钥大小。

  • 旧版函数仅支持 SHA2 用于摘要，并要求摘要用于签名。组件函数还支持 SHA3 用于摘要（前提是使用 OpenSSL 1.1.1），并且不要求摘要用于签名，尽管它们支持。

  • asymmetric_encrypt() 旧版函数支持使用私钥进行加密。asymmetric_encrypt() 组件函数仅接受公钥。建议您在旧版函数中也仅使用公钥进行加密。

  • create_dh_parameters() 和 asymmetric_derive() 用于 Diffie-Hellman 密钥交换方法的旧版函数不在 component_enterprise_encryption 组件中提供。

表 1 总结了由 openssl_udf 共享库提供的旧版函数与 MySQL 8.0.30 中 component_enterprise_encryption 组件提供的函数之间在支持和操作方面的技术差异。

表 8.48 MySQL 企业加密函数

能力旧版函数（到 MySQL 8.0.29）组件函数（从 MySQL 8.0.30）
加密方法RSA, DSA, Diffie-Hellman (DH)仅限 RSA
用于加密的密钥私钥或公钥仅限公钥
RSA 密钥格式PKCS #1 v1.5PKCS #8
最小 RSA 密钥大小1024 位2048 位
最大 RSA 密钥大小限制使用环境变量 MYSQL_OPENSSL_UDF_RSA_BITS_THRESHOLD 设置，默认限制为算法最大 16384使用系统变量 enterprise_encryption.maximum_rsa_key_size 设置，默认限制为 4096
摘要算法SHA2SHA2, SHA3 (需要使用 OpenSSL 1.1.1)
签名需要摘要支持摘要但不需要，可以使用任意长度的任意字符串
输出填充RSAES-PKCS1-v1_5RSAES-OAEP
签名填充RSASSA-PKCS1-v1_5RSASSA-PSS

8.6.2 配置 MySQL 企业加密

原文：dev.mysql.com/doc/refman/8.0/en/enterprise-encryption-configuring.html

MySQL 企业加密允许您限制密钥的长度，以满足您的安全要求，同时平衡资源使用。您还可以配置 MySQL 8.0.30 提供的component_enterprise_encryption组件的函数，以支持解密和验证由遗留openssl_udf共享库函数生成的内容。

组件函数对遗留函数的解密支持

默认情况下，MySQL 8.0.30 提供的component_enterprise_encryption组件的函数不会解密由早期版本中openssl_udf共享库提供的遗留函数生成的加密文本，或验证签名。组件函数假定加密文本使用 RSAES-OAEP 填充方案，签名使用 RSASSA-PSS 签名方案。然而，遗留函数生成的加密文本使用 RSAES-PKCS1-v1_5 填充方案，遗留函数生成的签名使用 RSASSA-PKCS1-v1_5 签名方案。

如果您希望组件函数支持 MySQL 8.0.30 之前的遗留函数生成的内容，请将组件的系统变量enterprise_encryption.rsa_support_legacy_padding设置为ON。该系统变量在安装组件时可用。当您将其设置为ON时，组件函数首先尝试解密或验证内容，假设其具有其正常方案。如果这种方式不起作用，它们还会尝试解密或验证内容，假设其具有遗留函数使用的方案。这种行为不是默认设置，因为它会增加处理无法解密或验证的内容所需的时间。如果您不处理由遗留函数生成的内容，请将系统变量保持默认设置为OFF。

密钥长度限制

随着密钥长度的增加，MySQL 企业加密的密钥生成函数所需的 CPU 资源量也会增加。对于一些安装来说，如果应用程序频繁生成过长的密钥，这可能导致不可接受的 CPU 使用率。

OpenSSL 指定所有密钥的最小长度为 1024 位。OpenSSL 还指定 RSA 密钥的最大长度为 16384 位，DSA 密钥为 10000 位，DH 密钥为 10000 位。

从 MySQL 8.0.30 开始，component_enterprise_encryption 组件提供的函数对于 RSA 密钥有更高的最小长度要求，为 2048 位，这符合当前最佳实践的最小密钥长度。组件的系统变量 enterprise_encryption.maximum_rsa_key_size 指定了最大密钥长度，默认为 4096 位。您可以更改此值以允许 OpenSSL 允许的最大长度，即 16384 位。

对于 MySQL 8.0.30 之前的版本，openssl_udf 共享库提供的传统函数默认使用 OpenSSL 的最小和最大限制。如果最大值过高，您可以使用以下系统变量指定较低的最大密钥长度：

  • MYSQL_OPENSSL_UDF_DSA_BITS_THRESHOLD：create_asymmetric_priv_key() 的最大 DSA 密钥长度（以位为单位）。此变量的最小值和最大值分别为 1024 和 10000。

  • MYSQL_OPENSSL_UDF_RSA_BITS_THRESHOLD：create_asymmetric_priv_key() 的最大 RSA 密钥长度（以位为单位）。此变量的最小值和最大值分别为 1024 和 16384。

  • MYSQL_OPENSSL_UDF_DH_BITS_THRESHOLD：create_dh_parameters() 的最大密钥长度（以位为单位）。此变量的最小值和最大值分别为 1024 和 10000。

要使用这些环境变量中的任何一个，请在启动服务器的进程的环境中设置它们。如果设置了这些变量，它们的值将优先于 OpenSSL 强制的最大密钥长度。例如，要为 create_asymmetric_priv_key() 的 DSA 和 RSA 密钥设置最大密钥长度为 4096 位，请设置这些变量：

export MYSQL_OPENSSL_UDF_DSA_BITS_THRESHOLD=4096
export MYSQL_OPENSSL_UDF_RSA_BITS_THRESHOLD=4096

本示例使用 Bourne shell 语法。其他 shell 的语法可能有所不同。

8.6.3 MySQL 企业加密用法和示例

原文：dev.mysql.com/doc/refman/8.0/en/enterprise-encryption-usage.html

在应用程序中使用 MySQL 企业加密时，调用适合所需操作的函数。本节演示了如何执行一些代表性任务。

在 MySQL 8.0.30 之前的版本中，MySQL 企业加密的函数基于openssl_udf共享库。从 MySQL 8.0.30 开始，这些函数由 MySQL 组件component_enterprise_encryption提供。在某些情况下，组件函数的行为与openssl_udf提供的旧版函数的行为不同。有关差异的列表，请参见升级 MySQL 企业加密。有关每个组件函数行为的详细信息，请参见第 8.6.4 节，“MySQL 企业加密函数参考”。

如果安装了旧版函数，然后升级到 MySQL 8.0.30 或更高版本，那么您创建的函数仍然可用，受支持，并且继续以相同方式工作。但是，从 MySQL 8.0.30 开始，它们已被弃用，并建议安装 MySQL 企业加密组件component_enterprise_encryption。有关升级说明，请参见从 MySQL 8.0.30 安装。

选择密钥长度和加密算法时，需要考虑以下一般因素：

  • 私钥和公钥的加密强度随着密钥大小的增加而增加，但密钥生成的时间也会增加。

  • 对于旧版函数，生成 DH 密钥比 RSA 或 DSA 密钥花费的时间更长。从 MySQL 8.0.30 开始，组件函数仅支持 RSA 密钥。

  • 非对称加密函数消耗的资源比对称函数多。它们适用于加密少量数据以及创建和验证签名。对于加密大量数据，对称加密函数更快。MySQL 服务器提供了AES_ENCRYPT()和AES_DECRYPT()函数用于对称加密。

可以在运行时创建密钥字符串值，并使用SET、SELECT或INSERT将其存储到变量或表中。此示例适用于组件函数和旧版函数。

SET @priv1 = create_asymmetric_priv_key('RSA', 2048);
SELECT create_asymmetric_priv_key('RSA', 2048) INTO @priv2;
INSERT INTO t (key_col) VALUES(create_asymmetric_priv_key('RSA', 1024));

存储在文件中的密钥字符串值可以由具有FILE权限的用户使用LOAD_FILE()函数读取。摘要和签名字符串可以类似地处理。

  • 创建私钥/公钥对

  • 使用公钥加密数据和私钥解密数据

  • 从字符串生成摘要

  • 使用密钥对生成摘要

创建私钥/公钥对

这个示例适用于组件功能和传统功能：

-- Encryption algorithm
SET @algo = 'RSA';
-- Key length in bits; make larger for stronger keys
SET @key_len = 2048;

-- Create private key
SET @priv = create_asymmetric_priv_key(@algo, @key_len);
-- Derive corresponding public key from private key, using same algorithm
SET @pub = create_asymmetric_pub_key(@algo, @priv);

您可以使用密钥对来加密和解密数据，或者用来签名和验证数据。

使用公钥加密数据和私钥解密数据

这个示例适用于组件功能和传统功能。在这两种情况下，密钥对的成员必须是 RSA 密钥：

SET @ciphertext = asymmetric_encrypt(@algo, 'My secret text', @pub);
SET @plaintext = asymmetric_decrypt(@algo, @ciphertext, @priv);

从字符串生成摘要

这个示例适用于组件功能和传统功能：

-- Digest type
SET @dig_type = 'SHA512';

-- Generate digest string
SET @dig = create_digest(@dig_type, 'My text to digest');

使用密钥对生成摘要

密钥对可用于签署数据，然后验证签名是否与摘要匹配。这个示例适用于组件功能和传统功能：

-- Encryption algorithm; keys must
-- have been created using same algorithm
SET @algo = 'RSA';
–- Digest algorithm to sign the data
SET @dig_type = 'SHA512';

-- Generate signature for digest and verify signature against digest
SET @sig = asymmetric_sign(@algo, @dig, @priv, @dig_type);
-- Verify signature against digest
SET @verf = asymmetric_verify(@algo, @dig, @sig, @pub, @dig_type);

对于传统功能，签名需要一个摘要。对于组件功能，签名不需要摘要，并且可以使用任何数据字符串。这些功能中的摘要类型指的是用于签署数据的算法，而不是用于创建签名的原始输入的算法。这个示例是针对组件功能的：

-- Encryption algorithm; keys must
-- have been created using same algorithm
SET @algo = 'RSA';
–- Arbitrary text string for signature
SET @text = repeat('j', 256);
–- Digest algorithm to sign the data
SET @dig_type = 'SHA512';

-- Generate signature for digest and verify signature against digest
SET @sig = asymmetric_sign(@algo, @text, @priv, @dig_type);
-- Verify signature against digest
SET @verf = asymmetric_verify(@algo, @text, @sig, @pub, @dig_type);

8.6.4 MySQL Enterprise Encryption Function Reference

原文：dev.mysql.com/doc/refman/8.0/en/enterprise-encryption-function-reference.html

在 MySQL 8.0.30 及之后的版本中，MySQL Enterprise Encryption 的函数由 MySQL 组件component_enterprise_encryption提供。有关它们的描述，请参见第 8.6.5 节，“MySQL Enterprise Encryption Component Function Descriptions”。

在 MySQL 8.0.30 之前的版本中，MySQL Enterprise Encryption 的函数基于openssl_udf共享库。如果已安装这些函数，则它们在后续版本中仍然可用，但已被弃用。有关它们的描述，请参见第 8.6.6 节，“MySQL Enterprise Encryption Legacy Function Descriptions”。

有关升级到由 MySQL 组件component_enterprise_encryption提供的新组件函数的信息，以及传统函数与组件函数之间行为差异的列表，请参见升级 MySQL Enterprise Encryption。

8.6.5 MySQL Enterprise Encryption 组件功能描述

原文：dev.mysql.com/doc/refman/8.0/en/enterprise-encryption-functions.html

从 MySQL 8.0.30 版本开始，MySQL Enterprise Encryption 的功能由 MySQL 组件 component_enterprise_encryption 提供。本参考描述了这些功能。

有关升级到由 MySQL 组件 component_enterprise_encryption 提供的新组件功能以及传统功能与组件功能之间行为差异的列表，请参阅 升级 MySQL Enterprise Encryption。

在 MySQL 8.0.30 之前基于 openssl_udf 共享库的传统功能的参考是 第 8.6.6 节，“MySQL Enterprise Encryption 传统功能描述”。

MySQL Enterprise Encryption 功能具有以下一般特性：

  • 对于错误类型的参数或不正确数量的参数，每个函数都会返回错误。

  • 如果参数不适合允许函数执行请求的操作，则返回适当的 NULL 或 0。例如，如果函数不支持指定的算法，密钥长度过短或过长，或者预期为 PEM 格式密钥字符串的字符串不是有效密钥。

  • 底层 SSL 库负责随机性初始化。

组件功能仅支持 RSA 加密算法。

更多示例和讨论，请参阅 第 8.6.3 节，“MySQL Enterprise Encryption 使用和示例”。

  • asymmetric_decrypt(*algorithm*, *data_str*, *priv_key_str*)

    使用给定算法和密钥字符串解密加密字符串，并将结果明文作为二进制字符串返回。如果解密失败，则结果为 NULL。

    对于在 MySQL 8.0.29 之前使用的此函数的传统版本，请参阅 第 8.6.6 节，“MySQL Enterprise Encryption 传统功能描述”。

    默认情况下，component_enterprise_encryption 函数假定加密文本使用 RSAES-OAEP 填充方案。如果系统变量 enterprise_encryption.rsa_support_legacy_padding 设置为 ON（默认为 OFF），则该函数支持通过遗留的 openssl_udf 共享库函数加密的内容的解密。当设置为 ON 时，该函数还支持 RSAES-PKCS1-v1_5 填充方案，这是遗留的 openssl_udf 共享库函数使用的填充方案。当设置为 OFF 时，无法解密由遗留函数加密的内容，对于这样的内容，函数返回空输出。

    algorithm 是用于创建密钥的加密算法。支持的算法值为 'RSA'。

    data_str 是要解密的加密字符串，该字符串是使用 asymmetric_encrypt() 加密的。

    priv_key_str 是一个有效的 PEM 编码的 RSA 私钥。为了成功解密，密钥字符串必须对应于与 asymmetric_encrypt() 一起使用的公钥字符串，以产生加密字符串。asymmetric_encrypt() 组件函数仅支持使用公钥进行加密，因此解密需要使用相应的私钥。

    有关用法示例，请参阅 asymmetric_encrypt() 的描述。

  • asymmetric_encrypt(*algorithm*, *data_str*, *pub_key_str*)

    使用给定的算法和密钥字符串加密字符串，并将结果密文作为二进制字符串返回。如果加密失败，则结果为 NULL。

    对于 MySQL 8.0.29 之前使用的旧版本函数，请参阅 Section 8.6.6, “MySQL Enterprise Encryption Legacy Function Descriptions”。

    algorithm 是用于创建密钥的加密算法。支持的算法值为 'RSA'。

    data_str 是要加密的字符串。此字符串的长度不能大于字节中的密钥字符串长度减去 42（用于填充）。

    pub_key_str 是一个有效的 PEM 编码的 RSA 公钥。asymmetric_encrypt() 组件函数仅支持使用公钥进行加密。

    要恢复原始未加密字符串，请将加密字符串传递给 asymmetric_decrypt()，以及用于加密的密钥对的另一部分，如下例所示：

    -- Generate private/public key pair
SET @priv = create_asymmetric_priv_key('RSA', 2048);
SET @pub = create_asymmetric_pub_key('RSA', @priv);

-- Encrypt using public key, decrypt using private key
SET @ciphertext = asymmetric_encrypt('RSA', 'The quick brown fox', @pub);
SET @plaintext = asymmetric_decrypt('RSA', @ciphertext, @priv);

    假设：

    SET @s = a string to be encrypted
SET @priv = a valid private RSA key string in PEM format
SET @pub = the corresponding public RSA key string in PEM format

    然后这些身份关系成立：

    asymmetric_decrypt('RSA', asymmetric_encrypt('RSA', @s, @pub), @priv) = @s

  • asymmetric_sign(*algorithm*, *text*, *priv_key_str*, *digest_type*)

    使用私钥签署摘要字符串或数据字符串，并将签名作为二进制字符串返回。如果签名失败，则结果为 NULL。

    对于在 MySQL 8.0.29 之前使用的此函数的旧版本，请参见 第 8.6.6 节，“MySQL 企业加密遗留函数描述”。

    algorithm 是用于创建密钥的加密算法。支持的算法值为 'RSA'。

    text 是数据字符串或摘要字符串。该函数接受摘要但不要求摘要，因为它还能处理任意长度的数据字符串。摘要字符串可以通过调用 create_digest() 生成。

    priv_key_str 是用于签署摘要字符串的私钥字符串。它必须是有效的 PEM 编码的 RSA 私钥。

    digest_type 是用于签署数据的算法。当使用 OpenSSL 1.0.1 时，支持的 digest_type 值为 'SHA224'、'SHA256'、'SHA384' 和 'SHA512'。如果使用 OpenSSL 1.1.1，则还可用额外的 digest_type 值 'SHA3-224'、'SHA3-256'、'SHA3-384' 和 'SHA3-512'。

    有关用法示例，请参阅 asymmetric_verify() 的描述。

  • asymmetric_verify(*algorithm*, *text*, *sig_str*, *pub_key_str*, *digest_type*)

    验证签名字符串是否与摘要字符串匹配，并返回 1 或 0 表示验证成功或失败。如果验证失败，则结果为 NULL。

    对于在 MySQL 8.0.29 之前使用的此函数的旧版本，请参见 第 8.6.6 节，“MySQL 企业加密遗留函数描述”。

    默认情况下，component_enterprise_encryption 函数假定签名使用 RSASSA-PSS 签名方案。如果系统变量 enterprise_encryption.rsa_support_legacy_padding 设置为 ON（默认为 OFF），该函数支持验证由旧版 openssl_udf 共享库函数生成的签名。当设置为 ON 时，该函数还支持 RSASSA-PKCS1-v1_5 签名方案，如旧版 openssl_udf 共享库函数所使用的。当设置为 OFF 时，无法验证由旧版函数生成的签名，并且对于这种内容，函数返回空输出。

    algorithm 是用于创建密钥的加密算法。支持的算法值为 'RSA'。

    text 是数据字符串或摘要字符串。该组件函数接受摘要但不需要它们，因为它还能处理任意长度的数据字符串。可以通过调用 create_digest() 来生成摘要字符串。

    sig_str 是要验证的签名字符串。可以通过调用 asymmetric_sign() 来生成签名字符串。

    pub_key_str 是签名者的公钥字符串。它对应于传递给 asymmetric_sign() 以生成签名字符串的私钥。它必须是有效的 PEM 编码的 RSA 公钥。

    digest_type 是用于签署数据的算法。在使用 OpenSSL 1.0.1 时，支持的 digest_type 值为 'SHA224'、'SHA256'、'SHA384' 和 'SHA512'。如果使用 OpenSSL 1.1.1，则还可以使用额外的 digest_type 值 'SHA3-224'、'SHA3-256'、'SHA3-384' 和 'SHA3-512'。

    -- Set the encryption algorithm and digest type
SET @algo = 'RSA';
SET @dig_type = 'SHA512';

-- Create private/public key pair
SET @priv = create_asymmetric_priv_key(@algo, 2048);
SET @pub = create_asymmetric_pub_key(@algo, @priv);

-- Generate digest from string
SET @dig = create_digest(@dig_type, 'The quick brown fox');

-- Generate signature for digest and verify signature against digest
SET @sig = asymmetric_sign(@algo, @dig, @priv, @dig_type);
SET @verf = asymmetric_verify(@algo, @dig, @sig, @pub, @dig_type);

  • create_asymmetric_priv_key(*algorithm*, *key_length*)

    使用给定的算法和密钥长度创建私钥，并以 PEM 格式的二进制字符串形式返回密钥。密钥采用 PKCS #8 格式。如果密钥生成失败，则结果为 NULL。

    对于 MySQL 8.0.29 之前使用的旧版本此函数，请参阅 Section 8.6.6, “MySQL Enterprise Encryption Legacy Function Descriptions”。

    algorithm 是用于创建密钥的加密算法。支持的算法值为 'RSA'。

    key_length 是密钥长度（以位为单位）。如果超过最大允许的密钥长度或指定少于最小值，则密钥生成失败，结果为 null 输出。密钥长度的最小允许值为 2048 位。最大允许的密钥长度是 enterprise_encryption.maximum_rsa_key_size 系统变量的值，默认为 4096。最大设置为 16384，这是 RSA 算法允许的最大密钥长度。请参阅 Section 8.6.2, “Configuring MySQL Enterprise Encryption”。

    注意

    生成更长的密钥可能会消耗大量 CPU 资源。使用 enterprise_encryption.maximum_rsa_key_size 系统变量限制密钥长度，可以在提供足够安全性的同时平衡资源使用。

    此示例创建一个 2048 位的 RSA 私钥，然后从私钥派生公钥：

    SET @priv = create_asymmetric_priv_key('RSA', 2048);
SET @pub = create_asymmetric_pub_key('RSA', @priv);

  • create_asymmetric_pub_key(*algorithm*, *priv_key_str*)

    使用给定算法从给定私钥派生公钥，并以 PEM 格式的二进制字符串返回该密钥。密钥采用 PKCS #8 格式。如果密钥派生失败，则结果为 NULL。

    对于 MySQL 8.0.29 之前使用的旧版函数，请参阅 Section 8.6.6, “MySQL Enterprise Encryption Legacy Function Descriptions”。

    algorithm 是用于创建密钥的加密算法。支持的算法值为 'RSA'。

    priv_key_str 是有效的 PEM 编码的 RSA 私钥。

    有关用法示例，请参阅 create_asymmetric_priv_key() 的描述。

  • create_digest(*digest_type*, *str*)

    使用给定摘要类型从给定字符串创建摘要，并将摘要作为二进制字符串返回。如果摘要生成失败，则结果为 NULL。

    对于 MySQL 8.0.29 之前使用的旧版函数，请参阅 Section 8.6.6, “MySQL Enterprise Encryption Legacy Function Descriptions”。

    生成的摘要字符串适用于与 asymmetric_sign() 和 asymmetric_verify() 一起使用。这些函数的组件版本接受摘要但不需要它们，因为它们能够处理任意长度的数据。

    digest_type 是用于生成摘要字符串的摘要算法。当使用 OpenSSL 1.0.1 时，支持的 digest_type 值为 'SHA224'、'SHA256'、'SHA384' 和 'SHA512'。如果使用 OpenSSL 1.1.1，则还可使用额外的 digest_type 值 'SHA3-224'、'SHA3-256'、'SHA3-384' 和 'SHA3-512'。

    str 是要生成摘要的非空数据字符串。

    SET @dig = create_digest('SHA512', 'The quick brown fox');

8.6.6 MySQL 企业加密传统函数描述

原文：dev.mysql.com/doc/refman/8.0/en/enterprise-encryption-functions-legacy.html

在 MySQL 8.0.30 之前的版本中，MySQL 企业加密的函数基于openssl_udf共享库。本参考描述了这些函数。如果已安装这些函数，则它们在后续版本中仍然可用，但已被弃用。

有关升级到由 MySQL 组件component_enterprise_encryption提供的新组件函数的信息，以及传统函数与组件函数之间的行为差异列表，请参阅升级 MySQL 企业加密。

组件函数的参考资料是第 8.6.5 节，“MySQL 企业加密组件函数描述”。

MySQL 企业加密函数具有以下一般特征：

  • 对于错误类型或不正确数量的参数，每个函数都会返回错误。

  • 如果参数不适合允许函数执行请求的操作，则它会返回适当的NULL或 0。例如，如果函数不支持指定的算法、密钥长度过短或过长，或者期望为 PEM 格式密钥字符串的字符串不是有效密钥。

  • 底层 SSL 库负责随机性初始化。

几个传统函数接受加密算法参数。以下表总结了每个函数支持的算法。

表 8.49 函数支持的算法

函数支持的算法
asymmetric_decrypt()RSA
asymmetric_derive()DH
asymmetric_encrypt()RSA
asymmetric_sign()RSA, DSA
asymmetric_verify()RSA, DSA
create_asymmetric_priv_key()RSA, DSA, DH
create_asymmetric_pub_key()RSA, DSA, DH
create_dh_parameters()DH

注意

尽管您可以使用 RSA、DSA 或 DH 加密算法之一创建密钥，但其他接受密钥参数的传统函数可能仅接受特定类型的密钥。例如，asymmetric_encrypt()和asymmetric_decrypt()仅接受 RSA 密钥。

更多示例和讨论，请参阅第 8.6.3 节，“MySQL 企业加密用法和示例”。

  • asymmetric_decrypt(*algorithm*, *crypt_str*, *key_str*)

    使用给定算法和密钥字符串解密加密字符串，并将结果明文作为二进制字符串返回。如果解密失败，则结果为NULL。

    openssl_udf 共享库函数无法解密由 MySQL 8.0.30 中提供的 component_enterprise_encryption 函数生成的内容。

    algorithm 是用于创建密钥的加密算法。支持的算法值为'RSA'。

    crypt_str 是要解密的加密字符串，该字符串是使用asymmetric_encrypt()加密的。

    key_str 是有效的 PEM 编码 RSA 公钥或私钥。为了成功解密，密钥字符串必须对应于与asymmetric_encrypt()一起使用的公钥或私钥字符串，以生成加密字符串。

    有关用法示例，请参阅asymmetric_encrypt()的描述。

  • asymmetric_derive(*pub_key_str*, *priv_key_str*)

    使用一方的私钥和另一方的公钥派生对称密钥，并将生成的密钥作为二进制字符串返回。如果密钥派生失败，则结果为NULL。

    pub_key_str 和 priv_key_str 是使用 DH 算法创建的有效 PEM 编码密钥字符串。

    假设您有两对公钥和私钥：

    SET @dhp = create_dh_parameters(1024);
SET @priv1 = create_asymmetric_priv_key('DH', @dhp);
SET @pub1 = create_asymmetric_pub_key('DH', @priv1);
SET @priv2 = create_asymmetric_priv_key('DH', @dhp);
SET @pub2 = create_asymmetric_pub_key('DH', @priv2);

    假设进一步假设您使用一对密钥的私钥和另一对密钥的公钥来创建对称密钥字符串。那么这个对称密钥的身份关系成立：

    asymmetric_derive(@pub1, @priv2) = asymmetric_derive(@pub2, @priv1)

    此示例需要 DH 私钥/公钥作为输入，使用共享的对称密钥创建。通过将密钥长度传递给create_dh_parameters()来创建密钥，然后将密钥作为“密钥长度”传递给create_asymmetric_priv_key()。

    -- Generate DH shared symmetric secret
SET @dhp = create_dh_parameters(1024);
-- Generate DH key pairs
SET @algo = 'DH';
SET @priv1 = create_asymmetric_priv_key(@algo, @dhp);
SET @pub1 = create_asymmetric_pub_key(@algo, @priv1);
SET @priv2 = create_asymmetric_priv_key(@algo, @dhp);
SET @pub2 = create_asymmetric_pub_key(@algo, @priv2);

-- Generate symmetric key using public key of first party,
-- private key of second party
SET @sym1 = asymmetric_derive(@pub1, @priv2);

-- Or use public key of second party, private key of first party
SET @sym2 = asymmetric_derive(@pub2, @priv1);

  • asymmetric_encrypt(*algorithm*, *str*, *key_str*)

    使用给定的算法和密钥字符串加密字符串，并将生成的密文作为二进制字符串返回。如果加密失败，则结果为NULL。

    algorithm 是用于创建密钥的加密算法。支持的算法值为'RSA'。

    str 是要加密的字符串。此字符串的长度不能大于密钥字符串长度（以字节为单位），减去 11（用于填充）。

    key_str 是有效的 PEM 编码 RSA 公钥或私钥。

    要恢复原始未加密的字符串，将加密字符串与用于加密的密钥对的另一部分一起传递给asymmetric_decrypt()，如下例所示：

    -- Generate private/public key pair
SET @priv = create_asymmetric_priv_key('RSA', 1024);
SET @pub = create_asymmetric_pub_key('RSA', @priv);

-- Encrypt using private key, decrypt using public key
SET @ciphertext = asymmetric_encrypt('RSA', 'The quick brown fox', @priv);
SET @plaintext = asymmetric_decrypt('RSA', @ciphertext, @pub);

-- Encrypt using public key, decrypt using private key
SET @ciphertext = asymmetric_encrypt('RSA', 'The quick brown fox', @pub);
SET @plaintext = asymmetric_decrypt('RSA', @ciphertext, @priv);

    假设：

    SET @s = a string to be encrypted
SET @priv = a valid private RSA key string in PEM format
SET @pub = the corresponding public RSA key string in PEM format

    那么这些身份关系成立：

    asymmetric_decrypt('RSA', asymmetric_encrypt('RSA', @s, @priv), @pub) = @s
asymmetric_decrypt('RSA', asymmetric_encrypt('RSA', @s, @pub), @priv) = @s

  • asymmetric_sign(*algorithm*, *digest_str*, *priv_key_str*, *digest_type*)

    使用私钥字符串对摘要字符串进行签名，并将签名作为二进制字符串返回。如果签名失败，则结果为NULL。

    algorithm 是用于创建密钥的加密算法。支持的算法值为'RSA'和'DSA'。

    digest_str 是摘要字符串。摘要字符串可以通过调用create_digest()生成。

    priv_key_str 是用于签署摘要字符串的私钥字符串。它可以是有效的 PEM 编码的 RSA 私钥或 DSA 私钥。

    digest_type 是用于签署数据的算法。支持的*digest_type*值为'SHA224'、'SHA256'、'SHA384'和'SHA512'。

    有关用法示例，请参阅asymmetric_verify()的描述。

  • asymmetric_verify(*algorithm*, *digest_str*, *sig_str*, *pub_key_str*, *digest_type*)

    验证签名字符串是否与摘要字符串匹配，并返回 1 或 0 以指示验证成功或失败。如果验证失败，则结果为NULL。

    openssl_udf共享库函数无法验证由 MySQL 8.0.30 提供的component_enterprise_encryption函数生成的内容。

    algorithm 是用于创建密钥的加密算法。支持的算法值为'RSA'和'DSA'。

    digest_str 是摘要字符串。需要一个摘要字符串，可以通过调用create_digest()生成。

    sig_str 是要验证的签名字符串。可以通过调用asymmetric_sign()生成签名字符串。

    pub_key_str 是签名者的公钥字符串。它对应于传递给asymmetric_sign()以生成签名字符串的私钥。它必须是有效的 PEM 编码的 RSA 公钥或 DSA 公钥。

    digest_type 是用于签署数据的算法。支持的*digest_type*值为'SHA224'、'SHA256'、'SHA384'和'SHA512'。

    -- Set the encryption algorithm and digest type
SET @algo = 'RSA';
SET @dig_type = 'SHA224';

-- Create private/public key pair
SET @priv = create_asymmetric_priv_key(@algo, 1024);
SET @pub = create_asymmetric_pub_key(@algo, @priv);

-- Generate digest from string
SET @dig = create_digest(@dig_type, 'The quick brown fox');

-- Generate signature for digest and verify signature against digest
SET @sig = asymmetric_sign(@algo, @dig, @priv, @dig_type);
SET @verf = asymmetric_verify(@algo, @dig, @sig, @pub, @dig_type);

  • create_asymmetric_priv_key(*algorithm*, {*key_len*|*dh_secret*})

    使用给定的算法和密钥长度或 DH 密钥创建私钥，并以 PEM 格式的二进制字符串形式返回密钥。密钥采用 PKCS #1 格式。如果密钥生成失败，则结果为NULL。

    algorithm 是用于创建密钥的加密算法。支持的算法值为'RSA'、'DSA'和'DH'。

    key_len 是 RSA 和 DSA 密钥的位数。如果超过最大允许的密钥长度或指定小于最小值，密钥生成将失败，结果为 null 输出。RSA 算法的最小允许密钥长度为 1,024 位，RSA 算法的最大允许密钥长度为 16,384 位，DSA 算法的最大允许密钥长度为 10,000 位。这些密钥长度限制是 OpenSSL 强加的约束。服务器管理员可以通过设置 MYSQL_OPENSSL_UDF_RSA_BITS_THRESHOLD、MYSQL_OPENSSL_UDF_DSA_BITS_THRESHOLD 和 MYSQL_OPENSSL_UDF_DH_BITS_THRESHOLD 环境变量来对最大密钥长度施加额外限制。参见 Section 8.6.2, “配置 MySQL 企业加密”。

    注意

    生成更长的密钥可能会消耗大量 CPU 资源。通过使用环境变量限制密钥长度，您可以在满足安全需求的同时平衡资源使用。

    dh_secret 是一个共享的 DH 密钥，必须传递给 DH 密钥而不是密钥长度。要创建这个密钥，请将密钥长度传递给 create_dh_parameters()。

    此示例创建了一个 2,048 位的 DSA 私钥，然后从私钥派生出一个公钥：

    SET @priv = create_asymmetric_priv_key('DSA', 2048);
SET @pub = create_asymmetric_pub_key('DSA', @priv);

    有关显示 DH 密钥生成的示例，请参阅 asymmetric_derive() 的描述。

  • create_asymmetric_pub_key(*algorithm*, *priv_key_str*)

    使用给定算法从给定私钥派生公钥，并以 PEM 格式的二进制字符串返回密钥。密钥采用 PKCS #1 格式。如果密钥派生失败，则结果为 NULL。

    algorithm 是用于创建密钥的加密算法。支持的算法值为 'RSA'、'DSA' 和 'DH'。

    priv_key_str 是一个有效的 PEM 编码的 RSA、DSA 或 DH 私钥。

    有关用法示例，请参阅 create_asymmetric_priv_key() 的描述。

  • create_dh_parameters(*key_len*)

    创建一个用于生成 DH 私钥/公钥对的共享密钥，并返回一个二进制字符串，可以传递给 create_asymmetric_priv_key()。如果密钥生成失败，则结果为 NULL。

    key_len 是密钥长度。位数最小和最大的密钥长度分别为 1,024 和 10,000。这些密钥长度限制是 OpenSSL 强加的约束。服务器管理员可以通过设置 MYSQL_OPENSSL_UDF_RSA_BITS_THRESHOLD、MYSQL_OPENSSL_UDF_DSA_BITS_THRESHOLD 和 MYSQL_OPENSSL_UDF_DH_BITS_THRESHOLD 环境变量来对最大密钥长度施加额外限制。参见 Section 8.6.2, “配置 MySQL 企业加密”。

    有关如何使用返回值生成对称密钥的示例，请参阅asymmetric_derive()的描述。

    SET @dhp = create_dh_parameters(1024);

  • create_digest(*digest_type*, *str*)

    使用给定的字符串和摘要类型创建摘要，并将摘要作为二进制字符串返回。如果摘要生成失败，则结果为NULL。

    生成的摘要字符串适用于与asymmetric_sign()和asymmetric_verify()一起使用。这些函数需要一个摘要。

    *digest_type是用于生成摘要字符串的摘要算法。支持的digest_type*值为'SHA224'、'SHA256'、'SHA384'和'SHA512'。

    *str*是要生成摘要的非空数据字符串。

    SET @dig = create_digest('SHA512', 'The quick brown fox');

8.7 SELinux

原文：dev.mysql.com/doc/refman/8.0/en/selinux.html

8.7.1 检查 SELinux 是否已启用

8.7.2 更改 SELinux 模式

8.7.3 MySQL 服务器 SELinux 策略

8.7.4 SELinux 文件上下文

8.7.5 SELinux TCP 端口上下文

8.7.6 SELinux 故障排除

安全增强型 Linux（SELinux）是一个强制访问控制（MAC）系统，通过为每个系统对象应用一个称为SELinux 上下文的安全标签来实现访问权限。SELinux 策略模块使用 SELinux 上下文来定义进程、文件、端口和其他系统对象之间如何相互交互的规则。只有在策略规则允许的情况下，系统对象之间的交互才被允许。

SELinux 上下文（应用于系统对象的标签）具有以下字段：user、role、type 和 security level。最常用于定义进程如何与其他系统对象交互的规则的是类型信息，而不是整个 SELinux 上下文。例如，MySQL SELinux 策略模块使用 type 信息定义策略规则。

您可以使用操作系统命令（如 ls 和 ps）以 -Z 选项查看 SELinux 上下文。假设 SELinux 已启用并且 MySQL 服务器正在运行，则以下命令显示 mysqld 进程和 MySQL 数据目录的 SELinux 上下文：

mysqld 进程：

$> ps -eZ | grep mysqld
system_u:system_r:mysqld_t:s0    5924 ?        00:00:03 mysqld

MySQL 数据目录：

$> cd /var/lib
$> ls -Z | grep mysql
system_u:object_r:mysqld_db_t:s0 mysql

其中：

  • system_u 是用于系统进程和对象的 SELinux 用户标识。

  • system_r 是用于系统进程的 SELinux 角色。

  • objects_r 是用于系统对象的 SELinux 角色。

  • mysqld_t 是与 mysqld 进程关联的类型。

  • mysqld_db_t 是与 MySQL 数据目录及其文件关联的类型。

  • s0 是安全级别。

有关解释 SELinux 上下文的更多信息，请参考您发行版的 SELinux 文档。

8.7.1 检查 SELinux 是否已启用

原文：dev.mysql.com/doc/refman/8.0/en/selinux-checking.html

在一些 Linux 发行版上，默认启用 SELinux，包括 Oracle Linux、RHEL、CentOS 和 Fedora。使用 sestatus 命令来确定您的发行版是否已启用 SELinux：

$> sestatus
SELinux status:                 enabled
SELinuxfs mount:                /sys/fs/selinux
SELinux root directory:         /etc/selinux
Loaded policy name:             targeted
Current mode:                   enforcing
Mode from config file:          enforcing
Policy MLS status:              enabled
Policy deny_unknown status:     allowed
Memory protection checking:     actual (secure)
Max kernel policy version:      31

如果 SELinux 已禁用或找不到 sestatus 命令，请在启用 SELinux 之前参考您的发行版 SELinux 文档以获取指导。

8.7.2 更改 SELinux 模式

原文：dev.mysql.com/doc/refman/8.0/en/selinux-mode.html

SELinux 支持强制执行、宽容和禁用模式。强制执行模式是默认模式。宽容模式允许在强制执行模式下不允许的操作，并将这些操作记录到 SELinux 审计日志中。宽容模式通常用于制定策略或故障排除。在禁用模式下，策略不会被执行，系统对象不会应用上下文，这使得以后启用 SELinux 变得困难。

要查看当前的 SELinux 模式，请使用之前提到的 sestatus 命令或 getenforce 实用程序。

$> getenforce
Enforcing

要更改 SELinux 模式，请使用 setenforce 实用程序：

$> setenforce 0
$> getenforce
Permissive

$> setenforce 1
$> getenforce
Enforcing

使用 setenforce 进行的更改在重新启动系统时会丢失。要永久更改 SELinux 模式，请编辑 /etc/selinux/config 文件并重新启动系统。

8.7.3 MySQL 服务器 SELinux 策略

原文：dev.mysql.com/doc/refman/8.0/en/selinux-policies.html

MySQL 服务器 SELinux 策略模块通常默认安装。您可以使用semodule -l命令查看已安装的模块。MySQL 服务器 SELinux 策略模块包括：

  • mysqld_selinux

  • mysqld_safe_selinux

有关 MySQL 服务器 SELinux 策略模块的信息，请参考 SELinux 手册页面。手册页面提供有关与 MySQL 服务相关的类型和布尔值的信息。手册页面的命名格式为*service-name*_selinux。

man mysqld_selinux

如果没有 SELinux 手册页面，请参考您的发行版 SELinux 文档，了解如何使用sepolicy manpage工具生成手册页面的信息。

8.7.4 SELinux 文件上下文

原文：dev.mysql.com/doc/refman/8.0/en/selinux-file-context.html

MySQL 服务器从许多文件中读取和写入。如果这些文件的 SELinux 上下文未正确设置，可能会拒绝对文件的访问。

接下来的说明使用 semanage 二进制文件来管理文件上下文；在 RHEL 上，它是 policycoreutils-python-utils 包的一部分：

yum install -y policycoreutils-python-utils

安装 semanage 二进制文件后，您可以使用 semanage 和 fcontext 选项列出 MySQL 文件上下文。

semanage fcontext -l | grep -i mysql

设置 MySQL 数据目录上下文

默认数据目录位置是 /var/lib/mysql/；使用的 SELinux 上下文是 mysqld_db_t。

如果您编辑配置文件以使用不同位置作为数据目录，或者用于数据目录中通常的任何文件（例如二进制日志），则可能需要为新位置设置上下文。例如：

semanage fcontext -a -t mysqld_db_t "/path/to/my/custom/datadir(/.*)?"
restorecon -Rv /path/to/my/custom/datadir

semanage fcontext -a -t mysqld_db_t "/path/to/my/custom/logdir(/.*)?"
restorecon -Rv /path/to/my/custom/logdir

设置 MySQL 错误日志文件上下文

RedHat RPM 的默认位置是 /var/log/mysqld.log；使用的 SELinux 上下文类型是 mysqld_log_t。

如果您编辑配置文件以使用不同位置，则可能需要为新位置设置上下文。例如：

semanage fcontext -a -t mysqld_log_t "/path/to/my/custom/error.log"
restorecon -Rv /path/to/my/custom/error.log

设置 PID 文件上下文

PID 文件的默认位置是 /var/run/mysqld/mysqld.pid；使用的 SELinux 上下文类型是 mysqld_var_run_t。

如果您编辑配置文件以使用不同位置，则可能需要为新位置设置上下文。例如：

semanage fcontext -a -t mysqld_var_run_t "/path/to/my/custom/pidfile/directory/.*?"
restorecon -Rv /path/to/my/custom/pidfile/directory

设置 Unix 域套接字上下文

Unix 域套接字的默认位置是 /var/lib/mysql/mysql.sock；使用的 SELinux 上下文类型是 mysqld_var_run_t。

如果您编辑配置文件以使用不同位置，则可能需要为新位置设置上下文。例如：

semanage fcontext -a -t mysqld_var_run_t "/path/to/my/custom/mysql\.sock"
restorecon -Rv /path/to/my/custom/mysql.sock

设置 secure_file_priv 目录上下文

对于自 MySQL 5.6.34、5.7.16 和 8.0.11 版本以来的 MySQL 版本。

安装 MySQL Server RPM 会创建一个 /var/lib/mysql-files/ 目录，但不会为其设置 SELinux 上下文。/var/lib/mysql-files/ 目录旨在用于诸如 SELECT ... INTO OUTFILE 等操作。

如果您通过设置 secure_file_priv 启用了对此目录的使用，则可能需要这样设置上下文：

semanage fcontext -a -t mysqld_db_t "/var/lib/mysql-files/(/.*)?"
restorecon -Rv /var/lib/mysql-files

如果您使用了不同位置，请编辑此路径。出于安全目的，此目录永远不应在数据目录内。

有关此变量的更多信息，请参阅secure_file_priv 文档。

8.7.5 SELinux TCP 端口上下文

原文：dev.mysql.com/doc/refman/8.0/en/selinux-context-tcp-port.html

8.7.5.1 设置 mysqld 的 TCP 端口上下文

8.7.5.2 设置 MySQL 功能端口的 TCP 端口上下文

接下来的说明将使用semanage二进制文件来管理端口上下文；在 RHEL 上，它是policycoreutils-python-utils软件包的一部分。

yum install -y policycoreutils-python-utils

安装完semanage二进制文件后，您可以使用semanage的port选项列出使用mysqld_port_t上下文定义的端口。

$> semanage port -l | grep mysqld
mysqld_port_t                  tcp      1186, 3306, 63132-63164
avatar
文章
阅读
粉丝