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 customerses 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.comProbado 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=MyMaskingDe 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 MyMaskingFilterDe la documentación, no probado aquí: Documentación de MariaDB MaxScale: filtro de masking
Parámetros
| Parámetro | Por defecto | Qué hace |
|---|---|---|
rules | obligatorio | Ruta del archivo de reglas |
warn_type_mismatch | never | Avisa cuando una columna enmascarada tiene un tipo que el filtro no enmascara |
large_payload | abort | ignore o abort con resultados de más de 16 MB |
prevent_function_usage | true | Rechaza funciones sobre columnas enmascaradas, como SELECT CONCAT(masked_column) FROM tbl |
require_fully_parsed | true | Rechaza las sentencias que MaxScale no puede parsear por completo |
treat_string_arg_as_field | true | Cubre el bypass con ANSI_QUOTES |
check_user_variables, check_unions, check_subqueries | true | Rechazan 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,SETy 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ón | Cambios en la app | Política por agente | Auditoría de lecturas enmascaradas | Licencia |
|---|---|---|---|---|
| Filtro de masking de MaxScale | Conectarse a través de MaxScale | Por cuenta, con applies_to / exempted | No es parte del filtro | BSL 1.1 (no open source); 26.10 necesita license key |
| Vista + privilegios de columna | Los clientes consultan la vista | Por usuario o rol | No es parte de la funcionalidad | MariaDB Server (GPL) |
| Columnas generadas | Cambio de esquema | Por usuario o rol | No es parte de la funcionalidad | MariaDB Server (GPL) |
| Proxy TCP de Vericto | Solo la cadena de conexión | Un proxy por camino de agente, más allowlists de agentes | Cada lectura enmascarada en el audit trail, con la columna | AGPL-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
- En el dashboard, en Bases de datos → Columnas sensibles, marcas columnas: tabla, columna, una política (
block,flagomask) y, paramask, un estilo:full([redacted]),last4,emailohash(SHA-256). - 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). - Con
mask, el proxy envía una query reescrita en el mismoCOM_QUERYoCOM_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. - Con
block, la query nunca llega a la base: el cliente recibeERROR 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 = 42Salida 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 columnSalida 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,
maskreescribe desde vericto-proxy 4.7.0 y vericto-eval 2.3.0; con versiones anteriores, una etiquetamaskbloquea 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_ROWSy 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 BYuORDER BYno 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_querypara que la aplicación la ejecute, MCP la devuelve como la únicaapproved_queryy la CLI la muestra como sugerencia.vericto-proxy mcpes 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:
- Documentación de MariaDB MaxScale: filtro de masking
- MariaDB MaxScale: todas las versiones
- Notas de MariaDB MaxScale 26.10.0 (license key, MXS-6274)
- Documentación de MariaDB MaxScale: license key
- MariaDB: proyectos bajo BSL 1.1 (MaxScale v2.0 a v24.02)
- MariaDB: Business Source License 1.1
- Archivo de licencia de MaxScale 24.08 (BSL 1.1)
- Documentación de MariaDB: GRANT (privilegios de columna)
- Documentación de MariaDB: CREATE VIEW
- Documentación de MariaDB: REGEXP_REPLACE
- Documentación de MariaDB: columnas generadas
- vericto-proxy 5.0.1: docs/SENSITIVE_COLUMNS.md
- vericto-engine 5.0.0 (código y README)
- Documentación de Vericto: columnas sensibles
Páginas relacionadas
- Data masking en bases de datos: opciones nativas y el enfoque de proxy
- Data masking en MySQL: funciones Enterprise, vistas, columnas generadas y proxy
- Data masking en PostgreSQL: vistas, la extensión anon, RLS y un proxy
- Cómo conectar agentes de IA a bases de datos: 5 formas, paso a paso
- Enmascaramiento de datos para Postgres y MySQL, en el proxy
- Documentación: columnas sensibles
- Documentación: allowlists de acceso de agentes
- Guía de integración: configurar el proxy TCP