Data masking en MariaDB: el filtro de MaxScale, vistas y proxy

MariaDB Server no tiene funciones de data masking. La opción de MariaDB es el filtro de masking de MaxScale, su proxy de base de datos, que reescribe los resultados; MaxScale no es open source (Business Source License) y la 26.10 necesita una license key. Dentro del servidor, se enmascara con vistas y privilegios de columna, o con columnas generadas.

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 MariaDB 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.

MariaDB Server no tiene funciones de masking

Las funciones de masking de MySQL Enterprise no existen en MariaDB, y la documentación de MariaDB Server no tiene una funcionalidad de masking: cada página de «masking» es de MaxScale. En MariaDB 11.4.13 no hay ninguna rutina llamada mask% en information_schema.ROUTINES ni ningún plugin %mask% en information_schema.ALL_PLUGINS. Lo que MariaDB sí tiene es REGEXP_REPLACE, útil para expresiones de masking:

SELECT mask_inner('4111111111114242', 0, 4);
SELECT REGEXP_REPLACE('ana@example.com', '^(.)[^@]*', '\\1***');
ERROR 1305 (42000) at line 35: FUNCTION shop.mask_inner does not exist
a***@example.com

Probado en MariaDB 11.4.13 (mariadb:11.4), el 2026-11-14.

El filtro de masking de MaxScale

El filtro de masking de MaxScale se ubica entre el cliente y el servidor y reemplaza los valores de las columnas indicadas en el resultado. La documentación es clara sobre su alcance: "the masking filter should be viewed as a best-effort solution intended for protecting against accidental misuse rather than malicious attacks."

Configuración

[MyMasking]
type=filter
module=masking
warn_type_mismatch=always
large_payload=abort
rules=masking_rules.json

[MyService]
type=service
...
filters=MyMasking

De la documentación, no probado aquí: Documentación de MariaDB MaxScale: filtro de masking

El archivo de reglas (una ruta relativa se resuelve contra /etc/maxscale.modules.d) contiene {"rules": [...]}. Cada regla tiene replace (una column, opcionalmente table y database, y un match pcre2 opcional para reemplazos parciales) y with (value y/o fill; value se usa solo si su longitud coincide exactamente, si no fill, por defecto X). applies_to y exempted, opcionales, listan cuentas. Una regla obfuscate reemplaza un valor de forma no reversible; la documentación advierte sobre la fuerza bruta cuando el rango de valores es chico.

{ "rules": [ { "replace": { "column": "ssn" }, "with": { "value": "012345-ABCD", "fill": "X" } } ] }

De la documentación, no probado aquí: Documentación de MariaDB MaxScale: filtro de masking

MaxScale> call command masking reload MyMaskingFilter

De la documentación, no probado aquí: Documentación de MariaDB MaxScale: filtro de masking

Parámetros

ParámetroPor defectoQué hace
rulesobligatorioRuta del archivo de reglas
warn_type_mismatchneverAvisa cuando una columna enmascarada tiene un tipo que el filtro no enmascara
large_payloadabortignore o abort con resultados de más de 16 MB
prevent_function_usagetrueRechaza funciones sobre columnas enmascaradas, como SELECT CONCAT(masked_column) FROM tbl
require_fully_parsedtrueRechaza las sentencias que MaxScale no puede parsear por completo
treat_string_arg_as_fieldtrueCubre el bypass con ANSI_QUOTES
check_user_variables, check_unions, check_subqueriestrueRechazan columnas enmascaradas leídas con variables de usuario, uniones y subqueries

Limitaciones documentadas

  • Solo enmascara tipos de texto y binarios (CHAR, VARCHAR, TEXT, BLOB, BINARY, ENUM, SET y sus variantes); "If the type of the column is something else, then no masking will be performed."
  • Solo funciona con paquetes de menos de 16 MB.
  • Un usuario que puede escribir puede copiar la columna a otra tabla y leerla (CREATE TABLE cheat …; INSERT INTO cheat SELECT ssn FROM users;), así que "the privileges of the users should be minimized."
  • Decide por nombre: si el resultado no trae información de la tabla, se enmascara cualquier columna con ese nombre.

Licencia y license key

  • MaxScale se distribuye bajo la Business Source License 1.1, que, según su propio texto, "is not an Open Source license". La página de BSL de MariaDB cubre MaxScale v2.0 a v24.02, con este Additional Use Grant: "You may use the Licensed Work when your application uses the Licensed Work with a total of less than three server instances in production." Cada versión pasa a GPL v2 o posterior después de su change date. El archivo de licencia de 24.08 tiene el mismo grant (change date 2027-09-09).
  • Al 14 de noviembre de 2026 no encontramos términos de licencia publicados para 25.01, 25.10 ni 26.10.
  • MaxScale 26.10 (publicada el 3 de noviembre de 2026) "does not start without a valid license key"; la clave viene de una suscripción de Enterprise Platform o de una prueba (notas de 26.10.0).

No ejecutamos MaxScale para esta guía: todo lo de esta sección sale de su documentación y de sus archivos de licencia.

Dentro del servidor: vistas, privilegios de columna y columnas generadas

MariaDB tiene privilegios de columna y vistas SQL SECURITY DEFINER (el valor por defecto), así que el patrón de MySQL funciona tal cual: el usuario lee solo las columnas inofensivas de la tabla, más una vista o columnas generadas con los valores enmascarados.

CREATE USER 'analyst'@'%' IDENTIFIED BY 'analyst-pw';
GRANT SELECT (id, name) ON shop.customers TO 'analyst'@'%';
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'@'%';

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'@'%';

Probado en MariaDB 11.4.13 (mariadb:11.4), el 2026-11-14.

Como analyst en MariaDB 11.4.13; fíjate en que el error 1142 nombra la tabla como `shop`.`customers`, a diferencia de MySQL:

-- The same customers table, analyst and support users, customers_masked view
-- and generated columns as in the MySQL guide. 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 `shop`.`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 MariaDB 11.4.13 (mariadb:11.4), el 2026-11-14.

Como support, card_last4 y email_masked devuelven 4242 / a***@example.com y 1881 / b***@example.org, y SELECT card_number falla con el mismo error 1143 que en MySQL. Las contrapartidas son las mismas: los clientes deben usar la vista, y las columnas generadas cambian el esquema.

MaxScale, vistas o un proxy

OpciónCambios en la appPolítica por agenteAuditoría de lecturas enmascaradasLicencia
Filtro de masking de MaxScaleConectarse a través de MaxScalePor cuenta, con applies_to / exemptedNo es parte del filtroBSL 1.1 (no open source); 26.10 necesita license key
Vista + privilegios de columnaLos clientes consultan la vistaPor usuario o rolNo es parte de la funcionalidadMariaDB Server (GPL)
Columnas generadasCambio de esquemaPor usuario o rolNo es parte de la funcionalidadMariaDB Server (GPL)
Proxy TCP de VerictoSolo la cadena de conexiónUn proxy por camino de agente, más allowlists de agentesCada lectura enmascarada en el audit trail, con la columnaAGPL-3.0-only

Los dos proxies se diferencian en dónde actúan: el filtro de MaxScale reemplaza valores en el resultado; Vericto reescribe la query antes de que llegue al servidor, así que el servidor calcula el valor enmascarado y el real nunca sale de él. Los dos agregan un salto; para Vericto publicamos lo que medimos, con el método, en el benchmark de latencia del proxy.

Enmascara columnas con Vericto

Vericto enmascara en el proxy TCP, entre el cliente y MariaDB: 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: