Data masking en MySQL: funciones Enterprise, vistas, columnas generadas y proxy

MySQL Community no tiene funciones de data masking. Las funciones de enmascaramiento (mask_inner, mask_pan, …) y las políticas de masking de 9.7 son parte de MySQL Enterprise Edition, un producto comercial. En Community, enmascara con una vista y privilegios de columna, con columnas generadas o con un proxy delante de la base.

Qué es el data masking y cuándo lo necesitas

El data masking (enmascaramiento de datos) devuelve un valor modificado en lugar del real: a***@example.com para un email, ****4242 para una tarjeta. La fila sigue ahí y la query sigue funcionando; la parte sensible no está en el resultado.

Lo necesitas en MySQL cuando alguien, o algo, debe consultar una tabla sin ver todas sus columnas:

  • Datos personales y de pago: emails, teléfonos, tarjetas, documentos de identidad.
  • Cumplimiento: los programas de GDPR, PCI DSS y HIPAA piden limitar quién ve datos personales y de tarjetas, y poder demostrarlo.
  • Analistas y soporte: necesitan las filas, no el número de tarjeta completo.
  • Agentes de IA: un SELECT email, card_number FROM customers es inofensivo para la base de datos y aun así pone datos personales en el contexto de un LLM.

Enmascarar al leer (dynamic masking) no cambia los datos guardados. Reescribir los datos guardados (static masking) es otro trabajo, para copias como las bases de prueba.

MySQL Enterprise Data Masking (solo Enterprise Edition)

El manual de 8.4 es explícito: "MySQL Enterprise Data Masking and De-Identification is an extension included in MySQL Enterprise Edition, a commercial product" (documentación de MySQL 8.4).

  • Empezó como plugin (data_masking.so) en MySQL 8.0.13; desde 8.0.33 también existe como componentes (componentes frente al plugin). En 9.7 el manual lo renombra «MySQL Enterprise Data Masking».
  • En 8.4 los componentes se instalan con un script que crea la tabla masking_dictionaries e instala component_masking y component_masking_functions. Antes, quita el plugin para evitar conflictos.
# MySQL Enterprise Edition 8.4: installs component_masking and component_masking_functions
mysql -u root -p -D mysql < [path/]masking_functions_install.sql

De la documentación, no probado aquí: MySQL 8.4: instalar los componentes de data masking

Las funciones enmascaran un valor (mask_inner(str, margin1, margin2 [, mask_char]), mask_outer, mask_pan, mask_pan_relaxed, mask_ssn, mask_iban, mask_uuid…) o generan datos falsos (gen_rnd_email, gen_rnd_pan, gen_range, gen_dictionary…). La lista completa está en la referencia de funciones. Los ejemplos de la documentación:

-- MySQL Enterprise Edition only. The values are the docs' examples;
-- gen_rnd_pan() returns a random card number.
SELECT mask_inner('abcdef', 1, 2);       -- aXXXef
SELECT mask_inner('abcdef', 0, 5);       -- Xbcdef
SELECT mask_pan(gen_rnd_pan());          -- XXXXXXXXXXXX9102
SELECT mask_pan_relaxed(gen_rnd_pan());  -- 551279XXXXXX3108
SELECT mask_ssn('909-63-6922');          -- ***-**-6922

De la documentación, no probado aquí: MySQL 8.4: descripción de las funciones de data masking

Se llaman en las queries o en vistas: el masking es algo que escribes en el SQL, no una propiedad de la columna. En la imagen Community nada de esto existe; esto pasa si lo intentas:

INSTALL COMPONENT 'file://component_masking';
INSTALL PLUGIN data_masking SONAME 'data_masking.so';
USE shop;
SELECT mask_inner('4111111111114242', 0, 4);
ERROR 1126 (HY000) at line 1: Can't open shared library '/usr/lib64/mysql/plugin/component_masking.so' (errno: 11 /usr/lib64/mysql/plugin/component_masking.so: cannot open shared object file: No such file or directory)
ERROR 1126 (HY000) at line 2: Can't open shared library '/usr/lib64/mysql/plugin/data_masking.so' (errno: 11 /usr/lib64/mysql/plugin/data_masking.so: cannot open shared object file: No such file or directory)
ERROR 1305 (42000) at line 2: FUNCTION shop.mask_inner does not exist

Probado en MySQL 8.4.13 Community (mysql:8.4), el 2026-11-14.

MySQL 9.7: políticas de dynamic data masking

MySQL 9.7 agrega un componente de Dynamic Data Masking Policy: "a MySQL Enterprise Edition feature which enables you to define masking expressions as policies on columns in a table" (documentación de 9.7). No está en el manual de 8.4.

-- MySQL 9.7 Enterprise Edition, after install_component_object_policy.sql
CREATE MASKING POLICY mask_password1(pass_column)
  CASE WHEN CURRENT_ROLE_IN('admin') THEN pass_column ELSE sha2(pass_column, 256) END;

-- A column takes a policy in CREATE TABLE or ALTER TABLE … ADD/MODIFY/CHANGE COLUMN:
--   ssn INT NOT NULL MASKING POLICY mask_ssn
ALTER TABLE user_data ALTER COLUMN ssn DROP MASKING POLICY;

De la documentación, no probado aquí: MySQL 9.7: cómo usar las políticas de masking

Restricciones documentadas: no admite políticas en columnas generadas ni en columnas que una columna generada referencia, en columnas indexadas, con histograma, en un CHECK o en la clave de particionado; y el tipo de la columna debe ser compatible con el resultado del CASE (en strings, la misma collation).

HeatWave: el manual de MySQL HeatWave lista 10 funciones de masking y de-identification soportadas (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), sin funciones de diccionario ni políticas de masking (documentación de HeatWave).

En Community: una vista de masking y privilegios de columna

El patrón que funciona en cualquier edición de MySQL: el usuario solo puede leer las columnas inofensivas de la tabla, más una vista que devuelve las sensibles enmascaradas. MySQL admite privilegios sobre columnas sueltas (SELECT, INSERT, UPDATE, REFERENCES), y una vista se ejecuta por defecto con los privilegios de quien la definió (SQL SECURITY DEFINER).

CREATE DATABASE shop; USE shop;
CREATE TABLE customers (id INT PRIMARY KEY, name VARCHAR(100) NOT NULL, email VARCHAR(255) NOT NULL,
  card_number VARCHAR(19) NOT NULL, ssn VARCHAR(11), created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP);
INSERT INTO customers (id, name, email, card_number, ssn) VALUES
  (1,'Ana','ana@example.com','4111111111114242','123-45-6789'),
  (2,'Bruno','bruno@example.org','5500000000001881','987-65-4321');

CREATE USER 'analyst'@'%' IDENTIFIED BY 'analyst-pw';
-- The analyst may read two columns of the table…
GRANT SELECT (id, name) ON shop.customers TO 'analyst'@'%';
-- …and the masked view, which runs with the definer's privileges.
CREATE SQL SECURITY DEFINER VIEW customers_masked AS
SELECT id, name,
       CONCAT(LEFT(email, 1), '***@', SUBSTRING_INDEX(email, '@', -1)) AS email,
       CONCAT('****', RIGHT(card_number, 4))                         AS card_number,
       CONCAT('XXX-XX-', RIGHT(ssn, 4))                               AS ssn
FROM customers;
GRANT SELECT ON shop.customers_masked TO 'analyst'@'%';

Probado en MySQL 8.4.13 Community (mysql:8.4), el 2026-11-14.

Como analyst, las columnas de la tabla se rechazan y la vista devuelve los valores enmascarados:

-- Connected as analyst:
SELECT email FROM customers;
SELECT * FROM customers;
SELECT * FROM customers_masked;
ERROR 1143 (42000) at line 3: SELECT command denied to user 'analyst'@'localhost' for column 'email' in table 'customers'
ERROR 1142 (42000) at line 4: SELECT command denied to user 'analyst'@'localhost' for table 'customers'
+----+-------+------------------+-------------+-------------+
| id | name  | email            | card_number | ssn         |
+----+-------+------------------+-------------+-------------+
|  1 | Ana   | a***@example.com | ****4242    | XXX-XX-6789 |
|  2 | Bruno | b***@example.org | ****1881    | XXX-XX-4321 |
+----+-------+------------------+-------------+-------------+

Probado en MySQL 8.4.13 Community (mysql:8.4), el 2026-11-14.

  • A favor: viene incluido, en cualquier edición, sin componentes extra.
  • En contra: cada cliente debe consultar la vista, no la tabla; una vista por audiencia; las expresiones de masking se mantienen a mano; un usuario con SELECT sobre la tabla se la saltea.
  • Una vista SQL SECURITY INVOKER comprueba los privilegios de quien la llama sobre la tabla, así que fallaría para analyst: usa DEFINER en las vistas de masking.

En Community: columnas generadas

Una columna generada calcula una copia enmascarada junto a la real. Una columna VIRTUAL no se guarda: se evalúa al leer las filas. Otorga la columna generada, no la original:

ALTER TABLE customers ADD COLUMN card_last4 VARCHAR(4)
  GENERATED ALWAYS AS (RIGHT(card_number, 4)) VIRTUAL;
ALTER TABLE customers ADD COLUMN email_masked VARCHAR(255)
  GENERATED ALWAYS AS (CONCAT(LEFT(email, 1), '***@', SUBSTRING_INDEX(email, '@', -1))) VIRTUAL;
CREATE USER 'support'@'%' IDENTIFIED BY 'support-pw';
GRANT SELECT (id, name, card_last4, email_masked) ON shop.customers TO 'support'@'%';

-- Connected as support:
SELECT id, name, card_last4, email_masked FROM customers;
SELECT card_number FROM customers WHERE id = 1;
|  1 | Ana   | 4242       | a***@example.com |
|  2 | Bruno | 1881       | b***@example.org |
ERROR 1143 (42000) at line 2: SELECT command denied to user 'support'@'localhost' for column 'card_number' in table 'customers'

Probado en MySQL 8.4.13 Community (mysql:8.4), el 2026-11-14.

El valor enmascarado queda en la misma tabla, así que las aplicaciones no necesitan una vista. A cambio, modifica el esquema de la tabla, y cada nueva columna enmascarada es una migración.

Opciones nativas frente al masking en el proxy

OpciónEdiciónCambios en la appPolítica por agenteAuditoría de lecturas enmascaradas
Funciones de masking de EnterpriseEnterprise Edition (comercial)Las queries o vistas deben llamar a las funcionesPor usuario, con vistas y grantsEnterprise Audit, si lo usas
Políticas de masking de 9.7Enterprise Edition, 9.7Ninguno en las queries; DDL para asignar políticasPor rol, dentro del CASE de la políticaNo es parte de la funcionalidad
Vista + privilegios de columnaCualquieraLos clientes consultan la vistaPor usuario o rolNo es parte de la funcionalidad
Columnas generadasCualquieraCambio de esquema; los clientes leen la columna nuevaPor usuario o rolNo es parte de la funcionalidad
Proxy TCP de VerictoCualquiera, incluidas Community, Aurora MySQL y MariaDBSolo la cadena de conexiónUn proxy por camino de agente, más allowlists de agentesCada lectura enmascarada en el audit trail, con la columna

Rendimiento: las funciones y las vistas corren dentro de MySQL; el proxy agrega un salto de red y una evaluación del AST por sentencia. Publicamos lo que medimos, con el método, en el benchmark de latencia del proxy; mide con tu propio tráfico.

Licencias: MySQL Enterprise Edition es comercial; las vistas, los grants y las columnas generadas son parte de MySQL Community (GPL); el proxy de Vericto es AGPL-3.0-only.

Enmascara columnas con Vericto

Vericto enmascara en el proxy TCP, entre el cliente y MySQL: sin cambiar la base de datos, sin cambiar la aplicación y sin MySQL Enterprise Edition. El proxy habla el protocolo de MySQL (VERICTO_WIRE_PROTOCOL=mysql; MariaDB y Aurora MySQL usan el mismo protocolo). Apuntas la cadena de conexión al proxy, con el mismo usuario y contraseña.

Cómo funciona

  1. En el dashboard, en Bases de datos → Columnas sensibles, marcas columnas: tabla, columna, una política (block, flag o mask) y, para mask, un estilo: full ([redacted]), last4, email o hash (SHA-256).
  2. En cada query, el engine lee el AST y encuentra qué columnas marcadas devuelve. Cada decisión se reporta con la regla VERICTO-085; si una query lee varias columnas marcadas, gana la política más estricta (block > mask > flag).
  3. Con mask, el proxy envía una query reescrita en el mismo COM_QUERY o COM_STMT_PREPARE, nunca la original. Los placeholders ? conservan su número y su orden, así que las sentencias preparadas se ejecutan sin cambios. La base calcula los valores enmascarados; el valor real nunca llega al cliente.
  4. Con block, la query nunca llega a la base: el cliente recibe ERROR 1142.

Esta es la reescritura real de vericto-engine 5.0.0 para una query que lee dos columnas enmascaradas, y las filas que devolvió en MySQL 8.4 y MariaDB 11.4:

-- The query the agent or the app sends (MySQL or MariaDB):
SELECT id, name, email, card_number FROM customers WHERE id = 42
-- FLAGGED VERICTO-085: SensitiveColumn > customers.card_number, customers.email (mask)
-- The query the proxy forwards instead (rewritten_query):
SELECT id, name, CASE WHEN CHAR_LENGTH((CONVERT((email) USING utf8mb4) COLLATE utf8mb4_bin)) = 0 THEN (CONVERT((email) USING utf8mb4) COLLATE utf8mb4_bin) WHEN LOCATE('@', (CONVERT((email) USING utf8mb4) COLLATE utf8mb4_bin), 2) > 0 THEN CONCAT(LEFT((CONVERT((email) USING utf8mb4) COLLATE utf8mb4_bin), 1), '***', SUBSTRING((CONVERT((email) USING utf8mb4) COLLATE utf8mb4_bin), LOCATE('@', (CONVERT((email) USING utf8mb4) COLLATE utf8mb4_bin), 2))) ELSE CONCAT(LEFT((CONVERT((email) USING utf8mb4) COLLATE utf8mb4_bin), 1), '***') END AS `email`, CASE WHEN CHAR_LENGTH((CONVERT((card_number) USING utf8mb4) COLLATE utf8mb4_bin)) <= 8 THEN '[redacted]' ELSE CONCAT('****', RIGHT((CONVERT((card_number) USING utf8mb4) COLLATE utf8mb4_bin), 4)) END AS `card_number` FROM customers WHERE id = 42

Salida real: vericto-engine 5.0.0, evaluate() on MySQL with customers.email (mask, email), customers.card_number (mask, last4) and customers.ssn (block), 2026-11-14.

-- The rows the masked rewrite returns:
+----+------+------------------+-------------+
| id | name | email            | card_number |
+----+------+------------------+-------------+
| 42 | Ana  | a***@example.com | ****4242    |
+----+------+------------------+-------------+

Probado en MySQL 8.4.13 Community (mysql:8.4) and MariaDB 11.4.13 (mariadb:11.4), el 2026-11-16.

Las máscaras usan solo funciones que existen en MySQL 5.7, 8.0, Aurora MySQL y MariaDB (sin REGEXP_REPLACE) y devuelven los mismos valores que en PostgreSQL. Un SELECT * sobre una tabla con columnas marcadas se bloquea, con un mensaje que pide listar las columnas:

SELECT * FROM customers
-- BLOCKED VERICTO-085: SensitiveColumn > * over customers (block): list the columns explicitly
-- Fix: List the columns explicitly: `*`, `t.*`, whole-row references and `COPY table TO` read every tagged column

Salida real: vericto-engine 5.0.0, evaluate() on PostgreSQL with customers.email (mask, email), customers.card_number (mask, last4) and customers.ssn (block), 2026-11-14.

Lo que conviene saber

  • Versiones: en MySQL, mask reescribe desde vericto-proxy 4.7.0 y vericto-eval 2.3.0; con versiones anteriores, una etiqueta mask bloquea la query.
  • La reescritura se imprime desde la sentencia parseada, así que no conserva comentarios ni formato. Una query que el engine no puede reproducir fielmente (hints del optimizador /*+ … */, SQL_CALC_FOUND_ROWS y los demás modificadores de SELECT, literales de bits) se bloquea en lugar de reescribirse. El texto que MySQL y el engine leerían distinto se bloquea con VERICTO-086.
  • Una columna que solo aparece en WHERE, JOIN, GROUP BY u ORDER BY no es una lectura, así que un agente podría inferir un valor filtrando por ella. Para agentes, agrega una allowlist de acceso de agentes, donde cuenta cada referencia.
  • Vericto decide por el nombre de la columna, no por su contenido; una columna renombrada pierde su etiqueta, y las vistas o funciones sobre una tabla marcada no quedan cubiertas salvo que también se marquen.
  • Solo el proxy TCP lo aplica. La API de runtime devuelve rewritten_query para que la aplicación la ejecute, MCP la devuelve como la única approved_query y la CLI la muestra como sugerencia. vericto-proxy mcp es solo para PostgreSQL en 5.0.1: para un agente sobre MySQL, usa el proxy TCP.
  • Las columnas sensibles necesitan un workspace de Vericto: la página de enmascaramiento indica dónde está disponible. El proxy es código abierto bajo la AGPL-3.0-only.

Mantén los privilegios de columna y las vistas como capa base; el proxy agrega políticas por base de datos, el audit trail de cada lectura enmascarada y un solo lugar para gestionarlas. Referencia completa: documentación de columnas sensibles.

Preguntas frecuentes

Fuentes

La documentación oficial que cita esta guía, revisada el 2026-11-14: