Data masking en PostgreSQL: vistas, la extensión anon, RLS y un proxy

PostgreSQL no trae funciones de enmascaramiento. Enmascaras datos con una vista más privilegios de columna, con la extensión postgresql_anonymizer (enmascaramiento dinámico, estático y dumps anonimizados) o en un proxy como Vericto, que reescribe la query sin cambiar la base ni la aplicación. El row-level security filtra filas, no columnas.

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

El data masking devuelve a***@example.com en lugar de ana@example.com a quien no debe ver el valor real. El enmascaramiento dinámico lo hace al leer, por rol o por cliente; el estático reescribe los datos, normalmente en una copia.

Lo necesitas para datos personales y de pago (PII), para cumplimiento normativo como el GDPR o PCI DSS, para analistas y soporte que necesitan las filas pero no los valores completos, y para agentes de IA: un agente que escribe su propio SQL lee todas las columnas que su rol permite, y esos valores terminan en el contexto del modelo.

Todos los ejemplos usan la misma tabla, customers(id, name, email, card_number, ssn, created_at), con dos filas: Ana y Bruno.

Opción 1: una vista que enmascara y privilegios de columna

La opción portable. Revoca la tabla, otorga las columnas seguras y expón las sensibles solo a través de una vista que las enmascara. Una vista corre con los privilegios de su dueño, así que el analista lee la vista sin tener SELECT sobre las columnas enmascaradas (reglas y privilegios, GRANT sobre columnas).

CREATE ROLE analyst LOGIN;
REVOKE ALL ON customers FROM PUBLIC;
GRANT SELECT (id, name) ON customers TO analyst;

CREATE VIEW customers_masked AS
SELECT id, name,
       left(email, 1) || '***@' || split_part(email, '@', 2) AS email,
       '****' || right(card_number, 4)                      AS card_number,
       'XXX-XX-' || right(ssn, 4)                            AS ssn,
       date_trunc('month', created_at)::date                 AS created_month
FROM customers;
GRANT SELECT ON customers_masked TO analyst;

SET ROLE analyst;
SELECT id, name FROM customers;
SELECT email FROM customers;
SELECT * FROM customers;
SELECT id, name, email, card_number, ssn FROM customers_masked;
-- SELECT id, name FROM customers: 2 rows (1 Ana, 2 Bruno)
-- SELECT email FROM customers:
ERROR:  permission denied for table customers
-- SELECT * FROM customers:
ERROR:  permission denied for table customers
-- SELECT … FROM customers_masked:
 id | name  |      email       | card_number |     ssn
----+-------+------------------+-------------+-------------
  1 | Ana   | a***@example.com | ****4242    | XXX-XX-6789
  2 | Bruno | b***@example.org | ****1881    | XXX-XX-4321
(2 rows)

Probado en PostgreSQL 17.11 and 18.6 (Docker images postgres:17 and postgres:18), el 2026-11-14.

El error no nombra la columna: permission denied for table customers. SELECT * también falla, porque incluye columnas que el rol no puede leer.

No hagas security_invoker la vista que enmascara

Con security_invoker = true, la tabla base se comprueba con los privilegios de quien consulta la vista (CREATE VIEW). El analista no tiene SELECT sobre card_number, así que la vista falla:

CREATE VIEW customers_masked_invoker WITH (security_invoker = true) AS
SELECT id, '****' || right(card_number, 4) AS card_number FROM customers;
GRANT SELECT ON customers_masked_invoker TO analyst;

SET ROLE analyst;
SELECT * FROM customers_masked_invoker;
ERROR:  permission denied for table customers

Probado en PostgreSQL 17.11 and 18.6 (Docker images postgres:17 and postgres:18), el 2026-11-14.

Qué puede salir mal

  • Todos los clientes deben consultar la vista. Una aplicación o un agente con permiso sobre la tabla lee los valores reales.
  • Cada columna sensible nueva exige cambiar la vista y los permisos.
  • Si la vista además filtra filas, la documentación recomienda security_barrier, que puede ser más lento.

Opción 2: la extensión postgresql_anonymizer

PostgreSQL Anonymizer (anon, de Dalibo, bajo The PostgreSQL License) declara las reglas de enmascaramiento como security labels sobre las columnas y las aplica de forma dinámica, estática o en dumps. Revisamos la versión 3.3.2 (28-10-2026); la 3.x soporta PostgreSQL 14 a 18. La 3.3.0 fue una versión de seguridad que corrigió 12 CVE, así que mantente en la última (changelog).

Instálala (de la documentación; la imagen oficial ya la traía cargada):

ALTER SYSTEM SET shared_preload_libraries = 'anon';  -- then restart PostgreSQL
CREATE EXTENSION anon;
SELECT anon.init();  -- loads the dataset the fake_* functions need

De la documentación, no probado aquí: PostgreSQL Anonymizer: instalación

Enmascaramiento dinámico

Las versiones actuales usan el enmascaramiento dinámico transparente: lo activas para la base, etiquetas las columnas y marcas un rol como MASKED (documentación). El rol enmascarado lee la misma tabla y recibe valores enmascarados:

-- As postgres, in database shop:
ALTER DATABASE shop SET anon.transparent_dynamic_masking TO true;

SECURITY LABEL FOR anon ON COLUMN customers.name
  IS 'MASKED WITH FUNCTION anon.dummy_first_name()';
SECURITY LABEL FOR anon ON COLUMN customers.email
  IS 'MASKED WITH FUNCTION anon.partial_email(email)';
SECURITY LABEL FOR anon ON COLUMN customers.card_number
  IS 'MASKED WITH FUNCTION anon.partial(card_number, 0, $$************$$, 4)';
SECURITY LABEL FOR anon ON COLUMN customers.ssn
  IS 'MASKED WITH VALUE $$XXX-XX-XXXX$$';

CREATE ROLE analyst LOGIN PASSWORD 'x';
SECURITY LABEL FOR anon ON ROLE analyst IS 'MASKED';
GRANT pg_read_all_data TO analyst;

-- As analyst, in a new connection:
SELECT id, name, email, card_number, ssn FROM customers;
EXPLAIN SELECT * FROM customers;
 id | name  |         email         |   card_number    |     ssn
----+-------+-----------------------+------------------+-------------
  1 | Nadia | an******@ex******.com | ************4242 | XXX-XX-XXXX
  2 | Will  | br******@ex******.org | ************1881 | XXX-XX-XXXX
(2 rows)

ERROR:  Anon: role is masked

Probado en postgresql_anonymizer 3.3.2 on PostgreSQL 18.6 (registry.gitlab.com/dalibo/postgresql_anonymizer:stable), el 2026-11-14.

  • anon.dummy_first_name() es aleatorio: las mismas filas salieron con otros nombres en una corrida posterior.
  • anon.partial_email() conserva dos caracteres iniciales, no uno.
  • La documentación lista lo que un rol enmascarado no puede hacer: usar EXPLAIN, definir security labels, usar planes cacheados que preparó otro rol o leer vistas SECURITY INVOKER.
  • La antigua anon.start_dynamic_masking() se eliminó:
SELECT anon.start_dynamic_masking();
ERROR:  function anon.start_dynamic_masking() does not exist

Probado en postgresql_anonymizer 3.3.2 on PostgreSQL 18.6 (registry.gitlab.com/dalibo/postgresql_anonymizer:stable), el 2026-11-14.

Enmascaramiento estático

El enmascaramiento estático reescribe los valores guardados. La documentación advierte que estos métodos destruyen los datos originales, así que úsalos sobre una copia. Desde la 3.2, la extensión se niega a enmascarar en nombre de un superusuario (anon.nosuperuser, activo por defecto); ejecútalo como dueño de la tabla:

-- As a superuser (anon.nosuperuser is on by default):
SELECT anon.anonymize_table('customers_copy');

-- As data_owner, a non-superuser that owns the table:
SELECT anon.anonymize_table('customers_copy');
SELECT id, name, email, card_number FROM customers_copy;
ERROR:  Anon: Static and dynamic masking cannot be used with a superuser if anon.nosuperuser is set to true.

 anonymize_table
-----------------
 t

  1 | Ana   | an******@ex******.com | ************4242
  2 | Bruno | br******@ex******.org | ************1881

Probado en postgresql_anonymizer 3.3.2 on PostgreSQL 18.6 (registry.gitlab.com/dalibo/postgresql_anonymizer:stable), el 2026-11-14.

Las funciones fake_* necesitan SELECT anon.init() antes de devolver valores; la documentación recomienda las funciones dummy_* para proyectos nuevos.

El row-level security filtra filas, no columnas

Las políticas de seguridad de filas restringen qué filas ve un rol. No cambian los valores de las filas que sí ve:

CREATE ROLE support LOGIN;
GRANT SELECT ON customers TO support;
ALTER TABLE customers ENABLE ROW LEVEL SECURITY;
CREATE POLICY support_sees_ana ON customers FOR SELECT TO support USING (id = 1);

SET ROLE support;
SELECT id, name, email, card_number FROM customers;
 id | name |      email      |   card_number
----+------+-----------------+------------------
  1 | Ana  | ana@example.com | 4111111111114242
(1 row)

Probado en PostgreSQL 17.11 and 18.6 (Docker images postgres:17 and postgres:18), el 2026-11-14.

El rol de soporte solo ve a Ana, con su email y su tarjeta completos. Usa RLS junto con el enmascaramiento, no en su lugar.

  • Los superusuarios y los roles con BYPASSRLS siempre saltean la seguridad de filas.
  • El dueño de la tabla también, salvo que actives ALTER TABLE … FORCE ROW LEVEL SECURITY.

pg_dump y dumps anonimizados

pg_dump no tiene una opción de enmascaramiento (documentación). Puede dejar datos fuera: --exclude-table-data conserva la definición de una tabla sin sus filas y, desde PostgreSQL 17, --filter lee patrones de inclusión y exclusión de un archivo y --exclude-extension omite una extensión. Comprobamos que pg_dump --help lista las dos en PostgreSQL 17 y 18.

# Keep the table definition, leave its rows out of the dump:
pg_dump shop --exclude-table-data=customers --file=shop.sql

De la documentación, no probado aquí: Documentación de PostgreSQL: pg_dump

Para un dump anonimizado, ejecuta pg_dump normal como un rol enmascarado por anon (dumps anónimos). --no-security-labels deja las reglas de enmascaramiento fuera del archivo:

pg_dump shop -h 127.0.0.1 --user analyst --no-security-labels --exclude-extension="anon" \
  --table=customers --data-only --inserts
INSERT INTO public.customers VALUES (1, 'Ceasar', 'an******@ex******.com', '************4242', 'XXX-XX-XXXX', '2026-11-14 18:00:09.102807+00');
INSERT INTO public.customers VALUES (2, 'Nadia', 'br******@ex******.org', '************1881', 'XXX-XX-XXXX', '2026-11-14 18:00:09.102807+00');

Probado en postgresql_anonymizer 3.3.2 on PostgreSQL 18.6 (registry.gitlab.com/dalibo/postgresql_anonymizer:stable), el 2026-11-14.

El antiguo wrapper pg_dump_anon se eliminó en la 2.5.0, según el changelog; la página de la documentación todavía dice que está deprecado.

Ventajas y desventajas: opciones nativas frente al proxy de Vericto

Vista + GRANT de columnaspostgresql_anonymizerRow-level securityProxy de Vericto
Qué enmascaraColumnas, a través de la vistaColumnas (dinámico, estático, dumps)Nada: filtra filasColumnas, en la query que envía el proxy
Cambios en la aplicaciónConsultar la vistaNinguno para el rol enmascaradoNingunoApuntar la conexión al proxy
Políticas por agenteUn rol por agentePor rol enmascaradoPor rolUn proxy y una base dedicados al camino del agente, más una allowlist de acceso de agentes
AuditoríaLogs de la baseLogs de la baseLogs de la baseUn evento del audit trail por lectura enmascarada, bloqueada o marcada, con la columna
RendimientoExpresiones en la baseFunciones de máscara en la basePredicados de la política en la baseUn salto más; la máscara corre en la base (benchmark)
SuperusuariosVen todoPor defecto no enmascara en su nombreLa salteanEnmascara cualquier rol que se conecte por el proxy
LicenciaPostgreSQLThe PostgreSQL LicensePostgreSQLAGPL-3.0-only

Enmascara columnas con Vericto

Vericto enmascara en el proxy, para agentes y aplicaciones, sin cambiar la base de datos ni la aplicación.

  • Marca columnas por base de datos en el dashboard de Vericto, cada una con una política: block (la query se bloquea), flag (pasa y queda registrada, con alerta) o mask (la proyección se reescribe), y para mask un estilo: full, last4, email o hash.
  • Cada lectura de una columna marcada se reporta como VERICTO-085. Si una query lee varias columnas marcadas, gana la política más estricta: block > mask > flag.
  • Vericto decide sobre el AST de la query, por el nombre de la columna. Nunca lee los resultados ni mira los valores.

El engine reescribe la proyección y la base calcula el valor enmascarado, así que el valor en claro nunca llega a Vericto ni al cliente. Esta es la reescritura real para PostgreSQL:

-- The query the agent or the app sends (PostgreSQL):
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, regexp_replace(email::text, '^(.)[^@]*(@.*)?$', E'\\1***\\2') AS email, CASE WHEN char_length(card_number::text) <= 8 THEN '[redacted]'::text ELSE '****' || "right"(card_number::text, 4) END AS card_number FROM customers WHERE id = 42

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.

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

Probado en PostgreSQL 17.11 and 18.6 (Docker images postgres:17 and postgres:18), el 2026-11-16.

El estilo last4 además reemplaza por [redacted] los valores de 8 caracteres o menos, como muestra el CASE de arriba.

Dónde es un control y dónde una recomendación

Cómo llega la query a la baseQué pasa con mask
Proxy TCP (protocolos de PostgreSQL y MySQL)El proxy envía la query reescrita, nunca la original; la base devuelve los valores enmascarados. Es un control.
API de runtime y SDKsLa respuesta trae rewritten_query; tu aplicación debe ejecutarla.
MCP (check_sql)La query enmascarada vuelve como la única approved_query; el agente debe seguirla.
CLI y API de validaciónLa versión enmascarada se muestra como sugerencia (CI, migraciones).

El enmascaramiento es un control solo cuando el agente o el cliente llega a los datos por el proxy TCP y no tiene otra credencial. Las columnas sensibles se configuran en un workspace de Vericto; la página de enmascaramiento indica dónde está disponible. vericto-proxy mcp aplica máscaras solo cuando está vinculado a un workspace: su modo local, sin cuenta, no tiene.

Qué cuenta como lectura

SELECT *, las referencias a la fila completa y COPY … TO sobre una tabla con columnas marcadas se bloquean bajo mask y block: lista 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.

Una columna block detiene la query:

SELECT id, ssn FROM customers
-- BLOCKED VERICTO-085: SensitiveColumn > customers.ssn (block)

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.

Una columna enmascarada se devuelve como texto, y cualquier expresión sobre ella se enmascara con full:

SELECT lower(email) FROM customers
-- FLAGGED VERICTO-085: SensitiveColumn > customers.email (mask)
-- rewritten_query (an expression over a masked column is masked full):
SELECT concat('[redacted]'::text, "left"(lower(email)::text, 0)) AS lower FROM customers

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.

Una columna que solo aparece en WHERE, JOIN, GROUP BY u ORDER BY no es una lectura:

SELECT id FROM customers WHERE email = 'ana@example.com'
-- FLAGGED VERICTO-050 (SELECT without LIMIT); no VERICTO-085:
-- a column used only in WHERE is not a read, nothing is masked

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.

Límites

  • Como filtrar no es leer, un agente puede deducir un valor enmascarado filtrando por él. Para un agente, 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; las vistas, funciones y particiones sobre una tabla marcada no quedan marcadas.
  • Con alguna etiqueta block o mask, una query que el engine no puede parsear se bloquea.
  • Copiar un valor enmascarado a otra tabla (INSERT … SELECT, CREATE TABLE AS) se bloquea, porque enmascararlo cambiaría los datos guardados.
  • Es defensa en profundidad: los privilegios de columna, las vistas y el RLS siguen siendo la base.

Preguntas frecuentes

Fuentes

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