Aplicación de políticas en las consultas
Unos 39 minutos de lectura, con 16 ejemplos en 13 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.31. Lee el original
En esta página
- Encuentra cada tabla y cada columna que lee una consulta
- Permitir solo tablas del catálogo, CTE y subconsultas
- Enmascarar referencias de columna filtra datos
- Reemplazar cada tabla con una subconsulta filtrada y enmascarada
- Escribe cada máscara en SQL en un solo lugar
- Construye filtros de filas a partir de los datos de la decisión
- Condiciona cada columna a los filtros de fila
- Prueba quién ve qué ejecutando consultas
- Oculta los grupos pequeños en los informes
- Entrega las mismas políticas a un motor que las haga cumplir
- Consultar en nombre de alguien
- Qué falla en producción
- Lo que decidió este capítulo
Al terminar este capítulo podrás aplicar decisiones de acceso a cada consulta que ejecute la plataforma. Reescribirás cada consulta para que cada tabla que lee sea reemplazada por una subconsulta que conserve solo las filas que el usuario puede ver y enmascare las columnas que no puede ver, rechazarás cualquier consulta que lea cualquier otra cosa, comprobarás quién obtiene qué ejecutando consultas reales, y dirás en qué punto una reescritura delante de DuckDB deja de proteger algo.
Una política protege el almacén de la plataforma de aprendizaje en línea solo si se cumple para cada consulta que llega a él, y ese almacén guarda los datos de contacto de los estudiantes, sus pagos y el texto que escriben. El capítulo 5 escribió la política de acceso de la plataforma en Rego. Dados un usuario, una tabla y las columnas que quiere, y opcionalmente el motivo por el que las quiere, la política devuelve una decisión: si permitir la lectura (allow), qué filtros de filas conservan las filas que el usuario puede ver, qué máscaras de columna cambian la forma en que se muestra una columna (redact, last4, pseudonymize o redact_contacts), y reasons. Una decisión no hace nada por sí sola. El SQL de un agente de soporte llega a DuckDB como texto, así que algo entre ambos debe aplicar la decisión a cada tabla que lee ese texto, sin importar cómo esté escrita la consulta.
El módulo compartido del libro lib.enforce aplica las decisiones; lo llamamos la capa de cumplimiento. Su Enforcer mantiene una conexión de DuckDB con una vista para cada tabla del catálogo (lib.warehouse.connect), el esquema de las tablas, la política y una clave para los seudónimos. Los usuarios nunca obtienen la conexión. Enforcer.sql(query, user) reescribe la consulta de un usuario y ejecuta la reescritura. Un servicio expone solo lib.enforce.answer, que la llama y devuelve las filas: nunca la relación, un acceso a la conexión, ni Enforcer.run, que ejecuta SQL escrito por la capa con la clave adjunta. El código usa sqlglot 30.33.0 y DuckDB 2.0.0.
Encuentra cada tabla y cada columna que lee una consulta
Una política solo puede decidir sobre lo que se le pregunta, así que la capa tiene que conocer cada tabla que lee una consulta y las columnas que lee de cada una. Deducir eso del texto SQL es un problema de análisis con trampas: *, alias, uniones con USING, expresiones de tabla comunes (CTE) e identificadores en cualquier mayúscula o minúscula. sqlglot convierte una consulta en un árbol, y su paso qualify resuelve cada columna contra un esquema, la califica con su tabla y expande * en las columnas que representa cuando tiene un esquema contra el cual expandirlo (qualify en v30.24.0). La capa construye ese esquema al iniciarse, listando las tablas del catálogo y leyendo las columnas y tipos de cada una desde la vista que lib.warehouse.connect creó para ella, de modo que una vista que DuckDB guarda para cualquier otra cosa nunca entra en el esquema.
Cuatro consultas, cada una con una trampa, muestran lo que devuelve Enforcer.reads: las columnas sobre las que se pregunta a la política, que deben coincidir con lo que nombra cada consulta.
1"""The columns four queries read from each table, and how each dialect normalizes the quoted name "LEARNERS". The2prose's point rests on the query with a CTE and on the normalization lines at the end."""3import sqlglot4from sqlglot import exp5from sqlglot.optimizer.normalize_identifiers import normalize_identifiers67from lib.catalog import open_catalog8from lib.enforce import Enforcer910# only these two tables are loaded, so the layer's schema holds nothing else11platform = Enforcer(open_catalog(["crm.learners", "support.tickets"]))1213# What each query reads, found by sqlglot's qualify against the catalog's schema, with `*` expanded.14queries = {15 "every column": "select * from crm.learners",16 "a join": """select l.country, count(*) as tickets17 from crm.learners as l join support.tickets as t using (learner_id) group by all""",18 # exclude drops notes from the CTE, so the reads name every other column of crm.learners19 "a CTE": """with emea as (select * exclude (notes) from crm.learners where support_region = 'emea')20 select email from emea""",21 "names in capitals": 'select EMAIL from "CRM"."LEARNERS"',22}23for name, sql in queries.items():24 for table, columns in platform.reads(sql).items():25 print(f"{name}, {table}: {', '.join(columns)}")2627# DuckDB resolves quoted capitals to the lowercase table. Whether sqlglot lowercases them depends on the dialect.28capitals = 'select count(*) from "CRM"."LEARNERS"'29print('DuckDB, "CRM"."LEARNERS":', f"{platform.connection.sql(capitals).fetchall()[0][0]:,} rows")30for dialect in ["duckdb", "trino", "postgres"]:31 # the name the dialect's parser resolves the quoted identifier to32 table = normalize_identifiers(sqlglot.parse_one('select * from "LEARNERS"', read=dialect), dialect=dialect).find(exp.Table)33 print(f'{dialect} normalizes "LEARNERS" to:', table.name)
python tables-a-query-reads.pyevery column, crm.learners: ai_training_consent, city, closed_at, country, date_of_birth, email, full_name, learner_id, marketing_consent, notes, phone, signup_at, status, street_address, support_region
a join, crm.learners: country, learner_id
a join, support.tickets: learner_id
a CTE, crm.learners: ai_training_consent, city, closed_at, country, date_of_birth, email, full_name, learner_id, marketing_consent, phone, signup_at, status, street_address, support_region
names in capitals, crm.learners: email
DuckDB, "CRM"."LEARNERS": 5,000 rows
duckdb normalizes "LEARNERS" to: learners
trino normalizes "LEARNERS" to: learners
postgres normalizes "LEARNERS" to: LEARNERS
Las lecturas siguen lo que una consulta nombra, no lo que devuelve. SELECT * lee cada columna de crm.learners, y la unión lee learner_id de ambas tablas, porque USING las compara, aunque ninguna aparezca en la salida. La CTE devuelve solo email, pero nombra todas las columnas de crm.learners excepto notes, así que la capa pregunta por todas ellas. Las lecturas de una consulta pueden ser más que lo que devuelve, nunca menos. "CRM"."LEARNERS" se resuelve también como crm.learners, porque la capa normaliza los identificadores como lo hace DuckDB: DuckDB devuelve 5,000 rows de crm.learners para ese nombre. El dialecto importa. sqlglot pasa "LEARNERS" a minúsculas para DuckDB y Trino, y lo conserva como LEARNERS para PostgreSQL, así que la capa normaliza con el dialecto del motor que ejecuta la consulta.
qualify tiene un hueco que determina el diseño de la capa: falla ante una columna desconocida de una tabla conocida, pero pasa por alto una tabla que no está en el esquema, y deja sin expandir su *. Ejecútalo sobre una unión con marketing.audience, que representa una tabla que un pipeline escribió después de leerse el esquema, y luego envía esa consulta y otras cinco lecturas a través de la capa:
1"""Runs sqlglot's qualify on a join with a table the schema lacks, then sends that join and five other reads through2the enforcement layer. The prose's point rests on the qualify line, where the star stays, and on the denial lines."""3import sqlglot4from sqlglot.optimizer.qualify import qualify56from lib.catalog import open_catalog7from lib.enforce import Denied, Enforcer89platform = Enforcer(open_catalog(["crm.learners"]))1011# marketing.audience stands for a table a pipeline wrote after the schema was read. qualify alone lets it through.12query = "select * from crm.learners as l join marketing.audience as a on a.learner_id = l.learner_id"13print("qualify on its own:", qualify(sqlglot.parse_one(query, read="duckdb"), schema=platform.schema, dialect="duckdb").sql("duckdb"))1415# The enforcement layer denies anything that isn't a catalog table, before it asks the policy.16attempts = {17 "a table missing from the catalog": query,18 "a column the table doesn't have": "select shoe_size from crm.learners",19 # scan_crm_learners is the scan lib.warehouse registers for crm.learners, and DuckDB resolves it like a table20 "the scan behind a view": "select count(*) from scan_crm_learners",21 "a Parquet file": "select count(*) from read_parquet('data/platform/learners.parquet')",22 "a table function": "select count(*) from query_table('crm.learners')",23 "a statement that isn't a query": "summarize crm.learners",24}25for name, sql in attempts.items():26 try:27 platform.rewrite(sql, "analyst-1")28 print(f"{name}: allowed")29 except Denied as reason:30 print(f"{name}: denied, {reason}")3132# What those reads would do on the layer's own connection, without the rewrite in front of it.33rows = lambda sql: f"{platform.connection.sql(sql).fetchall()[0][0]:,} rows"34print("the scan, run directly:", rows("select count(*) from scan_crm_learners"))35print("the table function, run directly:", rows("select count(*) from query_table('crm.learners')"))36try:37 rows("select count(*) from read_parquet('data/platform/learners.parquet')")38except Exception as error:39 print("the file, run directly:", str(error).split(":")[0])40# the layer turned external access off, and DuckDB refuses to turn it back on while the database runs41try:42 platform.connection.execute("set enable_external_access = true")43except Exception as error:44 print("turning external access back on:", str(error).split(": ", 1)[1])
python unknown-tables-denied.pyqualify on its own: SELECT * FROM "crm"."learners" AS "l" JOIN "marketing"."audience" AS "a" ON "a"."learner_id" = "l"."learner_id"
a table missing from the catalog: denied, not a table in the catalog: marketing.audience AS a
a column the table doesn't have: denied, Column 'shoe_size' could not be resolved. Line: 1, Col: 16
the scan behind a view: denied, not a table in the catalog: scan_crm_learners
a Parquet file: denied, not a table in the catalog: READ_PARQUET('data/platform/learners.parquet')
a table function: denied, not a table in the catalog: QUERY_TABLE('crm.learners')
a statement that isn't a query: denied, only a single query is allowed
the scan, run directly: 5,000 rows
the table function, run directly: 5,000 rows
the file, run directly: Permission Error
turning external access back on: Cannot enable external access while database is running
qualify por sí solo devuelve la consulta con SELECT * intacto y sin error, así que una capa que lo diera por bueno preguntaría a la política por crm.learners y dejaría pasar marketing.audience sin revisar. La capa deniega toda tabla fuera del catálogo antes de preguntar nada a la política, y qualify por sí mismo deniega una columna que la tabla no tiene. Las otras cuatro lecturas muestran por qué la regla es amplia. lib.warehouse registra el escaneo de cada tabla bajo un nombre propio, como scan_crm_learners. Ejecutado directamente en la conexión de la capa, ese escaneo devuelve 5,000 rows de alumnos sin filtrar. query_table lee cualquier tabla que nombre su cadena, y devuelve 5,000 rows cuando se ejecuta directamente. read_parquet lee un archivo, y SUMMARIZE no es una consulta que la reescritura pueda analizar. Las tres primeras no son tablas del catálogo y la última no es una consulta, así que las cuatro se deniegan. La conexión de la capa también tiene desactivado enable_external_access de DuckDB, de modo que una lectura de archivo que pasara la reescritura fallaría igualmente, con un Permission Error (Asegurar DuckDB).
Regla práctica: Pregunta a la política por cada tabla y cada columna que nombra una consulta, con * expandido contra el esquema del catálogo, y deniega todo lo que ese esquema no contenga: tablas desconocidas, archivos, funciones de tabla y sentencias distintas de una sola consulta. Una denegación cuesta una pregunta al equipo de la plataforma; un paso sin revisar cuesta lo que contenga la tabla.
Permitir solo tablas del catálogo, CTE y subconsultas
Denegar los nombres que el catálogo no contiene no basta por sí solo, porque una consulta puede leer datos a través de fuentes que no son nombres de tabla. Una función de tabla puede aparecer bajo LATERAL, o en una subconsulta de la lista de selección. Fuera del alcance de una CTE, o antes de que la CTE esté definida, DuckDB resuelve su nombre a lo que la conexión tenga bajo ese mismo nombre. Una comprobación que solo inspecciona nombres de tabla y acepta cualquier nombre que use una CTE deja pasar ambos casos.
Por eso la capa comprueba las fuentes contra una lista de permitidos. Enforcer.check_sources recorre la consulta completa y exige que cada FROM y cada JOIN fuente, en todos los niveles, sea una tabla del catálogo, una CTE en alcance o una subconsulta, y que cada LATERAL se aplique sobre una subconsulta. Todo lo demás se deniega, incluidas las funciones de tabla en cualquier posición, VALUES, UNNEST y los joins entre paréntesis. Una CTE está en alcance en su propia consulta, debajo de ella y en las CTE posteriores, y una recursiva también en la rama recursiva de su UNION. Una lista de permitidos falla de forma cerrada ante un tipo de fuente que nadie previó.
Una consulta que pasa por la capa no debe cambiar nada. La función escalar write_log de DuckDB escribe en el registro de consultas del motor. duckdb_functions() marca estas funciones: has_side_effects es «true si esta función modifica el estado de la base de datos» (DuckDB, duckdb_functions). En la 2.0.0 también marca funciones que solo varían, como random y uuid. La capa deniega toda función marcada, y toda macro que llame a una de ellas, como pg_sleep, leyendo la lista desde duckdb_functions() al arrancar. Una lista ordenada a mano en dañinas e inofensivas puede quedar desactualizada en una actualización sin que nadie lo note, y una lectura gobernada rara vez necesita un número aleatorio.
lib.enforce conserva los casos como prueba de regresión, source_cases, que la CI del capítulo 10 ejecuta junto con la prueba de orden de más abajo. Al ejecutarlos se ve cada denegación y si se registró algo:
1"""Runs the allowlist's regression cases through the layer and prints each denial with its reason; a case passes when it's2denied exactly when it must be and its parse logs nothing. The prose's points rest on the count of cases that pass, the functions-denied line and the allowed-query line at the end."""3from lib.catalog import open_catalog4from lib.enforce import MUST_ALLOW, MUST_DENY, Enforcer, source_cases56platform = Enforcer(open_catalog(["crm.learners", "support.tickets"]))78# The allowlist's regression test, lib.enforce.source_cases, which chapter 10's CI runs too: queries that read data9# other than through a catalog table, a call to each function DuckDB marks as having side effects, and a query the10# layer must still allow. A case passes when the layer denies it exactly when it must, and its parse logs nothing.11cases = source_cases(platform)12for case in cases:13 if case["case"] in MUST_DENY:14 print(f"{case['case']}:", f"denied, {case['reason']}" if case["denied"] else "ALLOWED")15functions = [case for case in cases if case["must"] == "deny" and case["case"] not in MUST_DENY]16print("functions with side effects:", ", ".join(case["case"].removeprefix("the function ") for case in functions))17print("functions with side effects, denied:", f"{sum(case['denied'] for case in functions)} of {len(functions)}")18print("cases whose parse sqlglot logged, quoting the query:", f"{sum(case['logged'] for case in cases)} of {len(cases)}")19passing = [case for case in cases if case["denied"] == (case["must"] == "deny") and not case["logged"]]20print("cases that pass:", f"{len(passing)} of {len(cases)}")2122# What two of the cases do on the layer's own connection, without the layer in front of it.23# the name is used before its CTE is defined, so DuckDB resolves it to the scan of the same name24before_the_cte = platform.connection.sql(MUST_DENY["a CTE's name before the CTE"]).fetchall()[0][0]25print("a CTE's name before the CTE, run directly:", f"{before_the_cte:,} rows")26# turns on DuckDB's query log, the one write_log writes into, so the entries below are what the call left27platform.connection.execute("CALL enable_logging('QueryLog')")28platform.connection.sql(MUST_DENY["a function that writes DuckDB's log"]).fetchall()29logged = [message for (message,) in platform.connection.sql("select message from duckdb_logs where type = 'QueryLog'").fetchall()]30print("the log function, run directly, query-log entries it leaves:", logged)3132# the query the allowlist must admit: a CTE, a join and a scalar subquery over catalog tables33for name, query in MUST_ALLOW.items():34 print(f"{name}, allowed:", f"{platform.sql(query, 'agent-a05').fetchall()[0][0]:,} rows")
python catalog-sources-only.pya table function in FROM: denied, not a table in the catalog: QUERY_TABLE('crm.learners')
a table function in a scalar subquery: denied, not a table in the catalog: QUERY_TABLE('crm.learners')
a table function under LATERAL: denied, a LATERAL that isn't a subquery: LATERAL QUERY_TABLE('crm.learners')
a catalog-qualified name: denied, not a table in the catalog: memory.crm.learners
an information_schema view: denied, not a table in the catalog: information_schema.tables
a CTE's name outside its scope: denied, not a table in the catalog: other
a CTE's name before the CTE: denied, not a table in the catalog: scan_crm_learners
a function that writes DuckDB's log: denied, a function DuckDB marks as having side effects: write_log
a statement sqlglot keeps as text: denied, only a single query is allowed
functions with side effects: current_connection_id, current_query, current_query_id, current_transaction_id, currval, error, gen_random_uuid, nextval, pg_sleep, random, setseed, setval, sleep_ms, stats, uuid, uuidv4, uuidv7, vector_type, write_log
functions with side effects, denied: 19 of 19
cases whose parse sqlglot logged, quoting the query: 0 of 29
cases that pass: 29 of 29
a CTE's name before the CTE, run directly: 5,000 rows
the log function, run directly, query-log entries it leaves: ["select write_log('an entry', log_type := 'QueryLog')", 'an entry']
a CTE, a join and a scalar subquery, allowed: 61 rows
Cada caso que la capa debe denegar se rechaza antes de consultar cualquier política, con un motivo que nombra la fuente. El análisis no debe dejar rastro propio. sqlglot registra como texto cualquier sentencia que conserve, como un CALL, con sus valores incluidos (código fuente de sqlglot, v30.24.0), así que la capa silencia las advertencias del analizador, y cada caso comprueba que no se registró nada. 29 of 29 casos pasan.
En la conexión propia de la capa, dos casos muestran lo que evitan sus denegaciones. El nombre usado antes de su CTE lee el escaneo del mismo nombre, 5,000 rows de estudiantes sin procesar (datos sin procesar), y write_log deja ["select write_log('an entry', log_type := 'QueryLog')", 'an entry'] en el registro de consultas: su propia sentencia, y una entrada que ninguna consulta hizo. Toda función con efectos secundarios se deniega, 19 of 19.
La lista de permitidos también debe dejar pasar las consultas ordinarias. Ejecutada como agent-a05, la agente de soporte de EMEA, una CTE, un join y una subconsulta escalar sobre tablas del catálogo devuelven 61 rows.
Regla práctica: Comprueba cada fuente contra una lista de permitidos de tablas del catálogo, CTE en alcance y subconsultas, deniega el resto, y deniega toda función que el motor marque como de efectos secundarios, leyéndola de su propia lista. Conserva los casos como prueba de regresión para cada cambio en la capa y en cada actualización del motor, y añade uno por cada nuevo tipo de fuente o función.
Enmascarar referencias de columna filtra datos
Con las columnas ya conocidas, la forma obvia de aplicar la política las reescribe: siempre que la consulta selecciona email y la decisión lo enmascara, se selecciona la máscara en su lugar. Solo necesita la lista de columnas de la primera sección, y parece correcta con las consultas que la gente prueba. Falla porque una consulta puede leer una columna sin seleccionarla, y DuckDB puede devolver una columna sin nombrarla.
Enforcer.mask_select_list hace la reescritura de columnas, conservada solo para mostrar su fallo. La probamos con cinco lecturas dirigidas al correo electrónico del alumno 2, ejecutadas como analyst-1, un científico de datos que puede leer crm.learners con email y las demás columnas personales seudonimizadas, y texto libre como notes redactado. La primera impresión es la reescritura de una lectura simple, con cualquier correo almacenado sustituido por un marcador, ya que los ejemplos nunca imprimen uno. Predice cuántas de las cinco detiene la reescritura:
1"""Masks the email in the select list only, then runs five reads aimed at one learner's email through that rewrite and2prints what each returns. The prose's point rests on the five attack lines, each of which returns learner 2's ID, the3stored email, or an error that holds it."""4import re56import duckdb78from lib.catalog import open_catalog9from lib.enforce import EMAIL, Enforcer1011platform = Enforcer(open_catalog(["crm.learners"]))12# analyst-1, a data scientist, may read crm.learners with `email` pseudonymized. The attacks aim at learner 2.13email = platform.connection.sql("select email from crm.learners where learner_id = 2").fetchall()[0][0]14print("the column rewrite:", platform.mask_select_list("select learner_id, email from crm.learners", "analyst-1"))1516attacks = {17 "a WHERE on the raw column": f"select learner_id from crm.learners where email = '{email}'",18 "the whole row as a struct": "select struct_extract(l, 'email') from crm.learners as l where learner_id = 2",19 "COLUMNS(...)": "select columns('^email$') from crm.learners where learner_id = 2",20 "to_json": "select to_json(l) ->> 'email' from crm.learners as l where learner_id = 2",21 "a cast error": "select learner_id from crm.learners where cast(email as integer) = 0",22}23for name, sql in attacks.items():24 try:25 # the column rewrite changes only the select list, so every other clause reads the stored email26 answer = str(platform.run(platform.mask_select_list(sql, "analyst-1")).fetchall())27 except duckdb.Error as error:28 answer = str(error).splitlines()[0]29 print(f"{name}:", re.sub(EMAIL, "<a stored email>", answer)) # the book never prints a stored email
python select-list-masks-leak.pythe column rewrite: SELECT "learners"."learner_id" AS "learner_id", SHA256($pseudonym_key || CAST("learners"."email" AS TEXT)) AS "email" FROM "crm"."learners" AS "learners"
a WHERE on the raw column: [(2,)]
the whole row as a struct: [('<a stored email>',)]
COLUMNS(...): [('<a stored email>',)]
to_json: [('<a stored email>',)]
a cast error: Conversion Error: Could not convert string '<a stored email>' to INT32 when casting from source column email
La reescritura de columnas no detiene ninguna de las cinco. Su reescritura de la lectura simple es correcta: email se devuelve como un hash. Las cinco lecturas la superan de tres maneras:
- Un
WHEREsobre la columna en bruto nunca pasa por la lista de selección, así que compara el correo almacenado. El analista adivina un correo y obtiene el ID del alumno 2,[(2,)], que vincula a esa persona con cada fila que pueda unir mediantelearner_id. - La fila completa como estructura,
COLUMNS(...)yto_jsondevuelven el correo almacenado,[('<a stored email>',)], sin ninguna referencia de columna llamadaemailque la reescritura pueda encontrar: DuckDB expande la fila, o compara nombres de columna con un patrón, por sí mismo. - Un error de conversión imprime un correo almacenado en su mensaje. Los errores de conversión de DuckDB incluyen el valor, y la documentación de PostgreSQL advierte que "la mayoría de las funciones de conversión incluyen sus valores de entrada en los mensajes de error que producen" (PostgreSQL 18, Rules and Privileges).
Enmascarar la columna dondequiera que la consulta la nombre, también en la cláusula WHERE, detendría la primera y la última lectura. No puede detener las tres del medio, porque nunca nombran la columna.
Regla práctica: No apliques máscaras reescribiendo referencias de columna. Por muchas formas de referencia que cubras, el motor tiene más maneras de leer una columna de las que la reescritura puede reconocer. En su lugar, enmascara en el origen de los datos, para que cada lectura vea el valor enmascarado, como lo hace la siguiente sección.
Reemplazar cada tabla con una subconsulta filtrada y enmascarada
Reescribir referencias a columnas filtra datos porque la tabla original permanece en la consulta. La solución reemplaza la tabla. Enforcer.rewrite sustituye cada tabla del catálogo que aparece en la consulta, bajo el alias que la consulta le asigna, por una subconsulta construida a partir de la decisión del usuario:
- todas las columnas de la tabla, en el orden de la tabla, de modo que
*, un struct oCOLUMNS(...)vea la forma que espera; - cada columna que la consulta lee, tal como está almacenada o enmascarada según indique la decisión, dentro de un
CASEsobre los filtros de fila que una sección posterior explica; - cada columna que no lee, como un
NULLcon tipo, ya que la política no fue consultada sobre ella; - una cláusula
WHEREcon cada filtro de fila de la decisión.
Todo lo que hace la consulta del usuario, desde su WHERE hasta sus lecturas de struct, ocurre entonces sobre esa subconsulta. Es el modelo que sigue el plugin OPA de Trino, donde un filtro de fila se comporta esencialmente como una cláusula WHERE adicional, como muestra la sección sobre motores.
Toma a instructor-17, quien consulta las reseñas con calificaciones bajas de sus cursos. La política conserva las reseñas de sus propios cursos y elimina los datos de contacto de body. La reescritura impresa muestra cómo:
1"""Rewrites instructor-17's query over the reviews, prints the rewrite and runs it. The prose's point rests on the two2result lines: how many reviews come back, and how many of them still hold an email."""3import sqlglot45from lib.catalog import open_catalog6from lib.enforce import Enforcer78platform = Enforcer(open_catalog(["learning.reviews"]))910# instructor-17 reads the low ratings of their courses' reviews. The policy filters reviews to their six courses and11# shows `body` with contact details removed.12query = "select course_id, rating, body from learning.reviews where rating <= 2"13# the query as text, with the reviews table replaced by a subquery built from the decision14rewritten = platform.rewrite(query, "instructor-17")15print(sqlglot.transpile(rewritten, read="duckdb", write="duckdb", pretty=True)[0])16print("reviews returned:", len(platform.run(rewritten).fetchall()))17print("of them holding an email:", platform.run(f"select count(*) from ({rewritten}) where body like '%@%'").fetchall()[0][0])
python table-rewrite.pySELECT
"reviews"."course_id" AS "course_id",
"reviews"."rating" AS "rating",
"reviews"."body" AS "body"
FROM (
SELECT
CAST(NULL AS BIGINT) AS review_id,
CAST(NULL AS BIGINT) AS learner_id,
CASE WHEN source.course_id IN (2, 75, 80, 87, 103, 134) THEN source.course_id END AS course_id,
CASE WHEN source.course_id IN (2, 75, 80, 87, 103, 134) THEN source.rating END AS rating,
CASE
WHEN source.course_id IN (2, 75, 80, 87, 103, 134)
THEN REGEXP_REPLACE(
REGEXP_REPLACE(source.body, '[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+', '[email]', 'g'),
'\+?\(?[0-9][0-9 ().-]{6,}[0-9]',
'[phone]',
'g'
)
END AS body,
CAST(NULL AS TIMESTAMPTZ) AS posted_at
FROM learning.reviews AS source
WHERE
source.course_id IN (2, 75, 80, 87, 103, 134)
) AS "reviews"
WHERE
"reviews"."rating" <= 2
reviews returned: 9
of them holding an email: 0
La consulta devuelve 9 reseñas, y 0 de ellas contienen un correo electrónico. La consulta del instructor permanece por fuera, calificada pero sin otros cambios. Por dentro, course_id y rating se muestran tal como están almacenadas, y body con la máscara redact_contacts, cada una dentro de un CASE sobre el filtro de fila, una lista literal de los cursos del instructor; las columnas que la consulta no lee aparecen como NULL con tipo.
Las cinco lecturas que vencieron la reescritura de columnas, ejecutadas por analyst-1 mediante la reescritura de tablas y mediante lib.enforce.answer, la función que un servicio llama en su frontera:
1"""Sends the five reads from the column rewrite through the table rewrite, and through `answer`, the service's boundary.2It then shows what the analyst receives and what the platform team's log holds. The prose's point rests on the five attack3lines, the operator's log line and the relation line."""4import logging5import re67from lib.catalog import open_catalog8from lib.enforce import EMAIL, Enforcer, QueryFailed, answer910platform = Enforcer(open_catalog(["crm.learners"]))11operator_log = [] # the platform team's log, kept in a list here so the example can print it12logging.getLogger("lib.enforce").addHandler(handler := logging.Handler())13handler.emit = lambda record: operator_log.append(record.getMessage().splitlines()[0])1415# The five attacks on the column rewrite, run by analyst-1 again: through the table rewrite this time, and through16# `answer`, the function a service calls at its boundary.17email = platform.connection.sql("select email from crm.learners where learner_id = 2").fetchall()[0][0]18attacks = {19 "a WHERE on the raw column": f"select learner_id from crm.learners where email = '{email}'",20 "the whole row as a struct": "select struct_extract(l, 'email') from crm.learners as l where learner_id = 2",21 "COLUMNS(...)": "select columns('^email$') from crm.learners where learner_id = 2",22 "to_json": "select to_json(l) ->> 'email' from crm.learners as l where learner_id = 2",23 "a cast error": "select learner_id from crm.learners where cast(email as integer) = 0",24}25# a pseudonym is 64 hex digits, shortened here; the example never prints a stored email26shorten = lambda text: re.sub(r"\b([0-9a-f]{8})[0-9a-f]{56}\b", r"\1…", re.sub(EMAIL, "<a stored email>", text))27for name, sql in attacks.items():28 try:29 # answer returns the rows, or raises QueryFailed with a generic message, as a service sees it30 got = str(answer(platform, sql, "analyst-1"))31 except QueryFailed as error:32 got = f"{type(error).__name__}, {error}"33 print(f"{name}:", shorten(got))34for line in operator_log:35 print("in the operator's log:", shorten(line)) # a pseudonym, 64 hex digits, shortened3637# Why `answer` returns rows: the relation Enforcer.sql returns is a handle on the layer's connection, and runs any SQL.38# the relation is a handle on the layer's connection, so its .query runs SQL of its own there39relation = platform.sql("select learner_id from crm.learners", "analyst-1")40print("the relation, running SQL of its own:", shorten(str(relation.query("r", "select email from crm.learners where learner_id = 2").fetchall())))41print("what answer returns:", type(answer(platform, "select learner_id from crm.learners", "analyst-1")).__name__)
python table-rewrite-holds.pya WHERE on the raw column: []
the whole row as a struct: [(None,)]
COLUMNS(...): [(None,)]
to_json: [(None,)]
a cast error: QueryFailed, the query failed: the platform team can see why
in the operator's log: a query by analyst-1 failed in the engine: Conversion Error: Could not convert string 'e4f62f1a…' to INT32 when casting from source column email
the relation, running SQL of its own: [('<a stored email>',)]
what answer returns: list
La reescritura detiene las cinco. El WHERE devuelve [], porque dentro de la subconsulta email ya es el seudónimo. El struct, las lecturas COLUMNS(...) y to_json devuelven NULL, no el seudónimo, porque esas consultas no nombran ninguna columna salvo learner_id. La política no fue consultada sobre ninguna otra columna, y el NULL con tipo no da ningún valor al resto. Una lectura que la reescritura no puede ver falla de forma segura. El error de conversión ahora contiene un seudónimo en lugar de un correo electrónico, y answer oculta incluso eso: obtiene las filas dentro de un try, convierte cualquier error del motor en QueryFailed y escribe el mensaje de DuckDB en el registro del equipo de plataforma, que el ejemplo muestra después de las cinco lecturas. El analista recibe QueryFailed, the query failed: the platform team can see why.
answer devuelve filas, no una relación, porque una relación de DuckDB ejecuta cualquier SQL en su conexión. La relación del analista, al pedir un correo electrónico, devuelve [('<a stored email>',)].
Generar la subconsulta para cada consulta, en lugar de escribir una vista por rol, es lo que la mantiene sincronizada con la política. Las decisiones de la plataforma dependen de la región, los cursos, el consentimiento y la finalidad, y una vista hecha a mano para cada combinación es la "explosión de roles" que describe NIST, donde las condiciones se convierten en "numerosos roles ad hoc con membresía limitada" (NIST SP 800-162). Tales vistas se desviarían de la política la primera vez que alguien editara solo una de ellas.
Regla práctica: Reemplaza cada tabla protegida por una subconsulta generada a partir de la decisión, bajo el alias de la consulta, y deja la consulta del usuario sin otros cambios. Asigna a las columnas no leídas un NULL con tipo. Si los usuarios necesitan lecturas de filas completas para mostrar valores, consulta a la política sobre cada columna de cada tabla, de modo que las máscaras las cubran todas, a costa de más solicitudes y registros de auditoría que nombran columnas que la consulta nunca usó.
Escribe cada máscara en SQL en un solo lugar
La política nombra una máscara; la capa decide en qué SQL se convierte. Mantener esa correspondencia en un solo lugar, la tabla MASKS en lib.enforce y el NULL tipado junto a ella, significa que una corrección a una máscara llega a cada tabla que la usa, y la política nunca lleva SQL, que sería código llegando como datos. La reescritura de tablas llama a lib.enforce.masked para cada columna enmascarada, e imprime el SQL de las cuatro máscaras que nombra la política:
1"""Prints the SQL the enforcement layer writes for each of the four masks the policy names, and counts DuckDB's functions2named like HMAC. The prose's points rest on the pseudonymize line and on the HMAC count."""3import duckdb4from sqlglot import exp56from lib.enforce import masked78# The four masks the policy names, as the SQL the enforcement layer writes for them.9# the column's type, which the redact mask casts its NULL to10for kind, column, type_ in [("redact", "date_of_birth", "DATE"), ("last4", "card_number", "VARCHAR"),11 ("pseudonymize", "email", "VARCHAR"), ("redact_contacts", "body", "VARCHAR")]:12 # redact is a typed NULL; the other masks' SQL comes from lib.enforce's MASKS table13 print(f"{kind}:", masked(kind, exp.column(column), type_).sql("duckdb"))1415# The pseudonymize mask hashes the key followed by the value, because DuckDB has no HMAC function to call.16# DuckDB's function catalog, searched for any name containing hmac, whatever its case17hmac = duckdb.sql("select count(*) from duckdb_functions() where function_name ilike '%hmac%'").fetchall()[0][0]18print("DuckDB functions named like HMAC:", hmac)
python masks-as-sql.pyredact: CAST(NULL AS DATE)
last4: RIGHT(REGEXP_REPLACE(card_number, '[^0-9]', '', 'g'), 4)
pseudonymize: SHA256($pseudonym_key || CAST(email AS TEXT))
redact_contacts: REGEXP_REPLACE(REGEXP_REPLACE(body, '[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+', '[email]', 'g'), '\+?\(?[0-9][0-9 ().-]{6,}[0-9]', '[phone]', 'g')
DuckDB functions named like HMAC: 0
Cada máscara cumple una función:
redactes unNULLconvertido al tipo de la columna, de modo que la columna conserva su tipo para cualquier cosa que la consulta haga con ella, como una unión o una función de fecha.last4conserva los últimos cuatro dígitos de un número de tarjeta, después de eliminar cualquier carácter que no sea un dígito.pseudonymizees un hash con clave, SHA-256 sobre la clave seguida del valor, porque DuckDB 2.0.0 no tiene una función HMAC:duckdb_functions()lista 0 funciones con nombres parecidos. Donde tu motor tenga una, prefiere HMAC (RFC 2104).redact_contactsreemplaza los correos electrónicos y los números de teléfono en texto libre por[email]y[phone].
Imagina a alguien que tiene una lista de los correos de la plataforma, que calcula el hash de cada uno y busca coincidencias entre los seudónimos que analyst-1 ve en crm.learners:
1"""Hashes a list of emails the way the layer hashes pseudonyms, with and without its key, then rotates the key and counts2the pseudonyms that change. The prose's points rest on the three count lines: the matches without the key and with it, and3the pseudonyms that change on rotation."""4from lib.catalog import open_catalog5from lib.enforce import Enforcer67# The pseudonyms analyst-1, the platform's data scientist, sees in crm.learners. Someone holding a list of the8# platform's emails hashes each one and looks for it among them, first without the key and then with it.9# an example key, not a secret: production keeps the real one where only the layer can read it10platform = Enforcer(open_catalog(["crm.learners"]), key="example-key-not-a-secret")11seen = platform.sql("select learner_id, email from crm.learners", "analyst-1").to_arrow_table()12platform.connection.register("seen", seen)13# a guess is an email's hash; the second also puts the key first, as the layer hashes a pseudonym14for name, guess in [("without the key", "sha256(email)"), ("with the key", "sha256($pseudonym_key || email)")]:15 matched = platform.run(f"select count(*) from crm.learners where {guess} in (select email from seen)").fetchall()[0][0]16 print(f"pseudonyms matched from a list of emails, {name}: {matched:,} of {seen.num_rows:,}")1718# A new key gives every learner a new pseudonym, so data pseudonymized under the old key no longer joins.19platform.key = "example-key-rotated"20rotated = platform.sql("select learner_id, email from crm.learners", "analyst-1").to_arrow_table()21# pairs each learner's old and new pseudonym, row by row22changed = sum(a != b for a, b in zip(seen["email"].to_pylist(), rotated["email"].to_pylist()))23print("pseudonyms that change when the key is rotated:", f"{changed:,} of {seen.num_rows:,}")
python pseudonym-key.pypseudonyms matched from a list of emails, without the key: 0 of 5,000
pseudonyms matched from a list of emails, with the key: 5,000 of 5,000
pseudonyms that change when the key is rotated: 5,000 of 5,000
La clave es lo que hace de un seudónimo un seudónimo. Sin ella, los hashes coinciden con 0 of 5,000 seudónimos; con ella, coinciden con 5,000 of 5,000, así que quien tenga la clave y una lista de correos puede identificar cada seudónimo de la lista. La clave pertenece solo a la capa. Queda fuera de la política, que es código que se lee en las revisiones de cambios, y fuera de la consulta, donde un usuario que eligiera la clave podría calcular seudónimos de correos adivinados. La capa pasa la clave a DuckDB como parámetro de consulta, de modo que no aparece en el texto de la consulta que registra el log de DuckDB, como muestra el capítulo 8, y la capa rechaza cualquier consulta de usuario que lleve un parámetro, ya que uno llamado $pseudonym_key recibiría la clave. En producción, guarda la clave en un gestor de secretos que solo pueda leer la capa. Rótala cuando pueda haberse filtrado, y prevé lo que implica la rotación: 5,000 of 5,000 seudónimos cambian, así que los datos seudonimizados con la clave antigua ya no se unen con los datos de la nueva.
redact_contacts son dos expresiones regulares, y conviene medir lo que eliminan. Los tickets y las reseñas de la plataforma traen todos los datos personales que el generador colocó en ellos, etiquetados por construcción, lo que el capítulo 3 llama la verdad. Cada texto pasa por la máscara aquí, y las etiquetas cuentan lo que sobrevive:
1"""Applies the redact_contacts mask to every ticket and review, then counts the labelled personal data still left in the2masked text, and the phone replacements made in the tickets. The prose's points rest on the 'left in the text' lines, the3replacement count, and the assert on the tickets' card, IBAN and date lines."""4import duckdb5from sqlglot import exp67from lib.enforce import masked8from lib.platform import load910# The redact_contacts mask, run over every ticket and review, against the personal data the generator placed in them11# (pii_spans, labelled by construction).12con = duckdb.connect()13# each table registers under its short name, which the queries below use14for name in ["support.tickets", "learning.reviews", "pii_spans"]:15 con.register(name.split(".")[-1], load(name))16mask = masked("redact_contacts", exp.column("body"), "VARCHAR").sql("duckdb")17# a span counts as left when its exact text is still in the masked body, which the row_id join finds18counts = con.sql(f"""19 with masked as (select 'tickets' as source, ticket_id as row_id, {mask} as body from tickets20 union all select 'reviews', review_id, {mask} from reviews)21 select source, entity, count(*), count(*) filter (where contains(masked.body, pii_spans.text))22 from pii_spans join masked using (source, row_id) group by all order by all""").fetchall()23# the phone pattern takes every card number, IBAN and date in the tickets, so none is left in the masked text24left_in_tickets = {entity: left for source, entity, _, left in counts if source == "tickets"}25assert all(left_in_tickets[entity] == 0 for entity in ("CREDIT_CARD", "IBAN_CODE", "DATE_TIME"))26for source, entity, placed, left in counts:27 print(f"{source}, {entity}, left in the text: {left:,} of {placed:,}")28# The phone pattern also takes card numbers, IBANs and dates, which are digits too.29replaced = con.sql(f"select sum(len(regexp_extract_all({mask}, '\\[phone\\]'))) from tickets").fetchall()[0][0]30print("[phone] replacements in tickets:", f"{replaced:,}")
python redact-contacts-recall.pyreviews, EMAIL_ADDRESS, left in the text: 0 of 120
reviews, PERSON, left in the text: 798 of 798
tickets, CREDIT_CARD, left in the text: 0 of 213
tickets, DATE_TIME, left in the text: 0 of 196
tickets, EMAIL_ADDRESS, left in the text: 0 of 423
tickets, IBAN_CODE, left in the text: 0 of 236
tickets, LOCATION, left in the text: 210 of 210
tickets, PERSON, left in the text: 1,657 of 1,657
tickets, PHONE_NUMBER, left in the text: 0 of 439
[phone] replacements in tickets: 1,520
La máscara elimina los datos de contacto y deja los nombres. En las reseñas, que los instructores y el asistente leen a través de esta máscara, quedan 0 of 120 correos electrónicos, y quedan 798 of 798 nombres.
En los tickets, quedan 0 of 439 números de teléfono, pero el patrón de teléfono hace 1,520 reemplazos. Los números de tarjeta, los IBAN y las fechas también son dígitos, así que el patrón los toma igualmente, y ninguno queda. Los nombres y las direcciones postales se conservan, así que la máscara no vuelve anónimo el texto.
Regla práctica: Mantén el SQL de cada máscara en una sola tabla de la capa de cumplimiento, y deja que la política nombre máscaras, nunca que las escriba. Genera cada seudónimo con una clave secreta que solo posea la capa, pasado como parámetro. Mide cada máscara de texto contra datos etiquetados antes de que una política dependa de ella, y nombra las máscaras por lo que eliminan, para que nadie lea redact_contacts como "anonimizado".
Construye filtros de filas a partir de los datos de la decisión
Las máscaras cambian la forma en que se muestra un valor; los filtros de filas deciden qué filas recibe un usuario. Llegan en una decisión como datos, en tres formas: una columna igual a un valor, una columna en una lista de valores y una comprobación de consentimiento sobre el alumno al que pertenece una fila. lib.enforce.row_filter convierte cada una en una condición SQL, con los valores escritos como literales SQL mediante sqlglot, nunca pegados en el texto SQL. Deniega la consulta si encuentra una forma que no conoce o una columna que la tabla no tiene, y la capa comprueba la columna de un filtro de consentimiento contra crm.learners antes de construir la comprobación. El capítulo 5 hizo que la política devolviera los filtros como datos por esta razón exacta: nada de lo que transporte una petición puede llegar a una consulta como código.
La forma de consentimiento es la que requiere más cuidado. El asistente del curso, assistant-1, solo puede leer reseñas de alumnos que aceptaron que su texto se usara para entrenar la IA de la plataforma, y ese consentimiento vive en crm.learners, tabla que el asistente no puede leer. La capa lo convierte en un semijoin, una prueba de que el learner_id de la reseña está entre los alumnos que consintieron, y lo ejecuta con el acceso propio de la capa a crm.learners:
1"""Prints the condition the layer writes for each row filter in three decisions, then the reviews the assistant reads2through its consent filter, and the denial of its read of the learners table. The prose's points rest on the read counts3and the consent counts, and on the denied read at the end."""4from lib.catalog import open_catalog5from lib.enforce import Enforcer, row_filter67platform = Enforcer(open_catalog(["crm.learners", "learning.reviews", "support.tickets"]))89# Each row filter in a decision, as the condition the enforcement layer writes for it.10for user, table in [("agent-a05", "support.tickets"), ("instructor-17", "learning.reviews"), ("assistant-1", "learning.reviews")]:11 # the decision for this read; its row filters are data, written as SQL in the loop below12 decision = platform.decide(user, {table: set()})[table]13 for rule in decision["row_filters"]:14 print(f"{user}, {table}: {row_filter(rule, platform.columns(table)).sql('duckdb')}")1516# A filter's values come from data, so a value that looks like SQL stays a value.17odd = {"column": "support_region", "equals": "emea' or '1' = '1"}18print("a region that looks like SQL:", row_filter(odd, platform.columns("support.tickets")).sql("duckdb"))1920# The assistant's consent filter reads crm.learners, which the assistant itself may not read.21total = platform.connection.sql("select count(*) from learning.reviews").fetchall()[0][0]22read = platform.sql("select count(*) from learning.reviews", "assistant-1").fetchall()[0][0]23print("reviews the assistant reads:", f"{read:,} of {total:,}")24# a null consent means no answer was recorded, so the label reads 'never asked'25by_consent = platform.connection.sql("""select coalesce(l.ai_training_consent::varchar, 'never asked'), count(*)26 from learning.reviews r join crm.learners l using (learner_id) group by all order by all""").fetchall()27for consent, reviews in by_consent:28 print(f"reviews whose author's AI-training consent is {consent}: {reviews:,}")29try:30 platform.sql("select count(*) from crm.learners", "assistant-1")31except Exception as reason:32 print("the assistant reading crm.learners:", reason)
python row-filters-from-data.pyagent-a05, support.tickets: source.support_region = 'emea'
instructor-17, learning.reviews: source.course_id IN (2, 75, 80, 87, 103, 134)
assistant-1, learning.reviews: source.learner_id IN (SELECT consent.learner_id FROM crm.learners AS consent WHERE consent.ai_training_consent IS TRUE)
a region that looks like SQL: source.support_region = 'emea'' or ''1'' = ''1'
reviews the assistant reads: 436 of 3,000
reviews whose author's AI-training consent is false: 955
reviews whose author's AI-training consent is never asked: 1,609
reviews whose author's AI-training consent is true: 436
the assistant reading crm.learners: assistant-1 may not read crm.learners: no group of this user may read this table
Los valores de cada filtro se convierten en literales SQL, de modo que un valor sigue siendo un valor, y un consentimiento sin respuesta cuenta como no. La región del agente y los cursos del instructor se convierten en una igualdad y en una lista IN, y una región escrita para parecer SQL sigue siendo una única cadena, con sus comillas duplicadas. El filtro de consentimiento comprueba IS TRUE, de modo que los autores de reseñas 1,609, que se registraron antes de que la plataforma hiciera la pregunta y no tienen respuesta registrada, cuentan como si no hubieran dado su consentimiento, igual que quienes dijeron que no.
El asistente lee las reseñas 436 of 3,000, que son las de autores que dijeron que sí. La petición del propio asistente para crm.learners se deniega, con el motivo que indica la política: la lectura del semijoin sobre esa tabla corresponde a la capa, no al usuario.
Regla práctica: Construye cada filtro de filas a partir de los valores de la decisión con un constructor SQL, y deniega cualquier forma de filtro o columna que la capa no reconozca. Trata un consentimiento desconocido como ausencia de consentimiento. Cuando un filtro necesite una tabla que el usuario no puede leer, léela con el acceso propio de la capa dentro de la subconsulta, y nunca ampliando el acceso del usuario.
Condiciona cada columna a los filtros de fila
Los filtros de fila están en la WHERE de la subconsulta, y la consulta del usuario envuelve la subconsulta, así que es tentador suponer que DuckDB aplica primero los filtros. SQL no garantiza ningún orden, y un optimizador mueve las condiciones hacia donde resulten más baratas. Una condición del usuario que puede fallar, como una conversión de tipo, podría entonces ejecutarse sobre filas que los filtros descartan, y un error genérico no ayuda: que la consulta falle dice algo sobre una fila que el usuario quizá no puede ver.
La documentación de PostgreSQL nombra esta fuga: una función que podría fallar según sus argumentos puede revelar información significativa sobre filas no visibles si se ejecuta antes que los filtros de fila de la vista. En PostgreSQL, una vista marcada como security_barrier impide que las "funciones y operadores elegidos maliciosamente reciban valores de filas hasta que la vista haya terminado su trabajo", y solo las funciones marcadas como LEAKPROOF pueden ejecutarse antes (PostgreSQL 18, Rules and Privileges). DuckDB no tiene ninguna de las dos cosas.
Por eso la capa hace que el orden sea irrelevante. Cada columna que lee la consulta sale de la subconsulta como CASE WHEN <row filters> THEN <value> END, como en la reescritura del instructor. Las condiciones del usuario dependen entonces del resultado de los filtros: independientemente de lo que DuckDB evalúe primero, en una fila descartada por los filtros ven NULL en todas las columnas.
lib.enforce.order_cases prueba cada forma de filtro que escribe la capa: la igualdad del agente de soporte, la lista IN del instructor y el semi-join de consentimiento del asistente del curso. Cada caso copia la tabla filtrada, con una columna body que contiene dígitos en las filas que el filtro conserva y texto en las que descarta, y después ejecuta una consulta que convierte body a número. Esa conversión solo falla si llega a ver el valor de una fila descartada:
1"""Runs the evaluation-order test for each filter shape the layer writes, with the filter in a WHERE alone and as the layer2writes it. The prose's point rests on the consent semi-join's two lines, and on the count at the end."""3from lib.enforce import order_cases45# The evaluation-order regression test, lib.enforce.order_cases, which chapter 10's CI runs on every DuckDB upgrade.6# For each shape of row filter the layer writes, it takes a real user's filter and a copy of the filtered table whose7# `body` holds digits in the rows the filter keeps and text in the rows it drops. A query that casts `body` to a number8# fails only if the cast sees a dropped row's value. It runs over the filter in a WHERE alone, and over the layer's9# subquery.10cases = order_cases()11for case in cases:12 for form, safe in [("with the filter in WHERE only", case["safe_with_where_only"]),13 ("as the layer writes it", case["safe_as_written"])]:14 print(f"{case['shape']}, {form}: the cast {'never saw' if safe else 'saw'} a dropped row's value")15print("filter shapes the layer's subquery keeps safe:", f"{sum(case['safe_as_written'] for case in cases)} of {len(cases)}")
python row-filter-order.pyequality, with the filter in WHERE only: the cast never saw a dropped row's value
equality, as the layer writes it: the cast never saw a dropped row's value
IN list, with the filter in WHERE only: the cast never saw a dropped row's value
IN list, as the layer writes it: the cast never saw a dropped row's value
consent semi-join, with the filter in WHERE only: the cast saw a dropped row's value
consent semi-join, as the layer writes it: the cast never saw a dropped row's value
filter shapes the layer's subquery keeps safe: 3 of 3
Condicionar cada columna es lo que mantiene segura el semi-join de consentimiento. Con el filtro solo en la WHERE, la igualdad y la lista IN eran seguras, y el semi-join de consentimiento no: DuckDB ejecutó la conversión sobre reseñas cuyos autores no habían dado su consentimiento. Tal como lo escribe la capa, 3 of 3 formas de filtro impiden que la conversión llegue a filas descartadas. Las dos primeras eran seguras por la elección del optimizador en 2.0.0, no por ninguna garantía, así que la prueba se ejecuta en cada actualización de DuckDB. La protección supone volver a evaluar los filtros en cada columna que lee la consulta.
Regla práctica: Nunca confíes en el orden de evaluación del motor para mantener las condiciones de un usuario alejadas de las filas que descarta un filtro. Haz que cada valor que pueda leer la consulta de un usuario dependa de los filtros de fila, y prueba cada forma de filtro en cada actualización del motor. Cuando un motor tiene una barrera propia, como las vistas security_barrier de PostgreSQL, úsala también.
Prueba quién ve qué ejecutando consultas
Capítulo 5 comprueba la política con una tabla de quién ve qué, lib.policy.WHO_SEES_WHAT: una lista de requests, cada una con la decisión que un revisor espera para ella. Eso prueba las decisiones, no lo que reciben los usuarios, que también depende de la reescritura, del SQL de las máscaras y de los datos. lib.enforce.observe ejecuta cada caso a través de la capa como el usuario del caso, y compara lo que se devuelve con lo almacenado: cuántas filas y qué columnas cambian. Un caso concuerda con su decisión cuando el usuario es denegado exactamente cuando el caso lo indica, recibe menos filas que las almacenadas exactamente cuando el caso espera un filtro de filas, y recibe valores cambiados exactamente en las columnas que el caso espera enmascarar:
1"""Runs chapter 5's who-sees-what cases as queries and compares what each user gets with what is stored, then reads2marketing.audience, which has no metadata. The prose's points rest on the agreement count and on the two marketing lines."""3from lib import pipelines, policy4from lib.catalog import open_catalog5from lib.enforce import Enforcer, agrees, observe67catalog = open_catalog(["crm.learners", "learning.reviews", "billing.payments", "learning.enrollments", "learning.courses"])8pipelines.run(catalog, "marketing_audience") # a copy of learners' names and emails, with no metadata yet9platform = Enforcer(catalog)1011# Chapter 5's who-sees-what table, run as queries: what each user gets, against what's stored. A column is "changed"12# when at least one value the user gets differs from the stored one.13agreeing = 014for case in policy.WHO_SEES_WHAT:15 got = observe(platform, case.user, case.table, case.columns, case.purpose)16 who = case.user + (f" for {case.purpose}" if case.purpose else "")17 if got is None:18 print(f"{who}, {case.table}: denied")19 else:20 print(f"{who}, {case.table}: {got['rows']:,} of {got['stored']:,} rows, changed: {', '.join(got['changed']) or 'none'}")21 agreeing += agrees(case, got)22print("cases where what the user gets agrees with the decision:", f"{agreeing} of {len(policy.WHO_SEES_WHAT)}")2324# marketing.audience is a table marketing may read, but nobody has classified its columns, so the policy treats each25# one as sensitive: marketing gets every row, and no value in any column.26rows = platform.sql("select * from marketing.audience", "marketing-1").fetchall()27# a column counts as shown when one of its values isn't None, which is what a redact mask returns28shown = sum(any(value is not None for value in column) for column in zip(*rows))29print("marketing-1, marketing.audience, which has no metadata, rows:", f"{len(rows):,}")30print("marketing-1, marketing.audience, which has no metadata, columns with a value:", f"{shown} of {len(rows[0])}")
python who-sees-what-in-queries.pyagent-a05, crm.learners: 1,581 of 5,000 rows, changed: none
agent-a05, billing.payments: denied
instructor-17, learning.reviews: 69 of 3,000 rows, changed: body
instructor-17, crm.learners: denied
marketing-1, crm.learners: 1,861 of 5,000 rows, changed: phone
finance-1, billing.payments: 17,562 of 17,562 rows, changed: card_number
analyst-1, billing.payments: 17,562 of 17,562 rows, changed: card_number
analyst-1, crm.learners: 5,000 of 5,000 rows, changed: email, notes
analyst-1, learning.reviews: 3,000 of 3,000 rows, changed: body
analyst-1 for ai-training, learning.reviews: 436 of 3,000 rows, changed: body
assistant-1, learning.reviews: 436 of 3,000 rows, changed: body
someone-else, crm.learners: denied
cases where what the user gets agrees with the decision: 12 of 12
marketing-1, marketing.audience, which has no metadata, rows: 1,829
marketing-1, marketing.audience, which has no metadata, columns with a value: 0 of 5
Lo que reciben los usuarios concuerda con la decisión en 12 of 12 casos. El agente de soporte de EMEA recibe los alumnos de su región tal como están almacenados, marketing recibe los alumnos activos que han dado su consentimiento, con phone cambiado, y el analista recibe todos los alumnos con email y notes cambiados. Las dos últimas líneas cubren marketing.audience, que un pipeline escribe y que nadie ha clasificado todavía. Marketing puede leerla y recibe 1,829 filas con 0 of 5 columnas con un valor, porque la política trata una columna sin clasificar como sensible.
La prueba se gana su lugar cuando hay un cambio. Supongamos que una pull request añade analyst-1 al grupo de soporte de EMEA, para que puedan ayudar con los tickets. Es un cambio de dos líneas en governance/users.toml, un grupo y el filtro de filas que necesita el soporte de la región. El código siguiente aplica ese cambio en memoria y ejecuta los mismos casos contra él:
1"""Makes one change to the users file in memory, runs the who-sees-what cases again, and runs chapter 5's decision check2on the same change. The prose's points rest on the lines that say which cases fail, and on the decision count."""3from lib import policy4from lib.catalog import open_catalog5from lib.enforce import Enforcer, agrees, observe67# A pull request changes one user in governance/users.toml, in two lines: analyst-1 joins support, with the region8# support's row filter needs, EMEA, to help with tickets.9# the users file as a document, changed here in memory and not on disk10data = policy.data_document()11data["platform"]["users"]["analyst-1"] = {"groups": ["data-science", "support"], "region": "emea"}12platform = Enforcer(open_catalog(["crm.learners", "learning.reviews", "billing.payments"]),13 rego=policy.interpreter(data=data))1415# The who-sees-what cases, run as queries with the change in place. The cases are unchanged: they say what each16# user should get, and the change was meant to touch support tickets only.17failing = 018for case in policy.WHO_SEES_WHAT:19 got = observe(platform, case.user, case.table, case.columns, case.purpose)20 # got is None when the user is denied, which agrees only with a case that expects a denial21 if not agrees(case, got):22 failing += 123 who = case.user + (f" for {case.purpose}" if case.purpose else "")24 print(f"fails, {who}, {case.table}, rows: {got['rows']:,} of {got['stored']:,}")25 print(f"fails, {who}, {case.table}, columns changed: {', '.join(got['changed']) or 'none'}, "26 f"expected: {', '.join(case.masked)}")27print("cases that fail:", f"{failing} of {len(policy.WHO_SEES_WHAT)}")2829# Chapter 5's table, which checks the decisions themselves, on the same change.30decisions = [policy.decide(policy.request(c.user, c.table, c.columns, c.purpose), platform.rego) for c in policy.WHO_SEES_WHAT]31print("cases that fail as decisions:", f"{sum(not policy.matches(c, d) for c, d in zip(policy.WHO_SEES_WHAT, decisions))} of {len(decisions)}")
python group-change-caught.pyfails, analyst-1, crm.learners, rows: 1,581 of 5,000
fails, analyst-1, crm.learners, columns changed: none, expected: email, notes
fails, analyst-1, learning.reviews, rows: 3,000 of 3,000
fails, analyst-1, learning.reviews, columns changed: none, expected: body
fails, analyst-1 for ai-training, learning.reviews, rows: 436 of 3,000
fails, analyst-1 for ai-training, learning.reviews, columns changed: none, expected: body
cases that fail: 3 of 12
cases that fail as decisions: 3 of 12
El cambio hace fallar 3 of 12 casos, y ninguno trata de tickets. Los tres son lecturas del analista sobre alumnos y reseñas. En crm.learners, el analista ahora recibe 1,581 of 5,000 filas sin ninguna columna cambiada: el filtro de región de soporte se aplica a ellas, y las máscaras de columnas personales de la política solo se aplican a usuarios fuera de soporte, así que cada correo y cada nota llega tal como está almacenado. El texto de las reseñas, que de otro modo un científico de datos no podría leer en absoluto, o leería con los contactos eliminados para el entrenamiento de IA, llega completo. La tabla a nivel de decisión del capítulo 5 falla en los mismos casos, 3 of 12; esta muestra lo que recibe el analista.
Regla práctica: Ejecuta los casos de quién ve qué como consultas a través de la capa en cada cambio de las políticas, del archivo de usuarios, de los metadatos o de la capa, y haz que la compilación falle cuando algún caso no concuerde. Corrige un caso que falle cambiando la política o el archivo de usuarios. Cambia un caso solo cuando los responsables de los datos estén de acuerdo en que lo que debe recibir el usuario ha cambiado.
Oculta los grupos pequeños en los informes
Los filtros de filas y las máscaras deciden qué filas y qué valores ve un usuario. Los agregados son un segundo canal: un recuento o un promedio sobre unas pocas personas describe a esas personas. La defensa habitual es un tamaño mínimo de grupo, por debajo del cual un grupo informado se oculta. El número es una regla práctica, no una medición. Un acuerdo público de uso de datos de los Centros de Servicios de Medicare y Medicaid de EE. UU. fija 11, y añade que "no se pueden usar porcentajes ni otras fórmulas matemáticas si el resultado muestra una celda con menos de 11" (CMS-R-0235L). La plataforma usa el mismo mínimo, 11, y lo guarda en governance/enforcement.toml, donde un cambio se revisa como un cambio de política, y lib.enforce.minimum_group_size lo lee.
Los instructores reciben un informe diario del curso con los estudiantes y el progreso medio por curso y por país del estudiante, generado por un proceso que lee países que los instructores no pueden leer. Los instructores sí pueden leer las inscripciones de sus propios cursos con el progreso de cada una. Combinar esos dos datos da el informe de instructor-17:
1"""Builds instructor-17's daily course report, counts its cells under the minimum and its cells of one learner, and matches2each cell of one against the enrollments the instructor may read. The prose's points rest on the cell and lookup counts, and3on the last line, which shows the differencing."""4from lib.catalog import open_catalog5from lib.enforce import Enforcer, minimum_group_size67platform = Enforcer(open_catalog(["crm.learners", "learning.courses", "learning.enrollments"]))8minimum = minimum_group_size()9print("minimum group size:", minimum)10count = lambda sql: platform.connection.sql(f"select count(*) from ({sql})").fetchall()[0][0]1112# The platform's daily course report for instructor-17: learners and average progress, per course and learner country.13# The report job reads learners' countries, which instructors may not read.14platform.connection.execute("""create view mine as15 select e.course_id, e.progress_pct, e.enrolled_at::date as day, l.country16 from learning.enrollments e join crm.learners l using (learner_id)17 where e.course_id in (select course_id from learning.courses where instructor_id = 17)""")18platform.connection.execute("""create view report as19 select course_id, country, count(*) as learners, avg(progress_pct) as progress from mine group by all""")20print("cells in the report:", count("from report"))21# the minimum is the threshold: a cell with fewer learners than it is held back22print("cells under the minimum:", count(f"from report where learners < {minimum}"))2324# instructor-17 may read their courses' enrollments, with each one's progress. A cell of one learner, matched on its25# progress, names that learner's country.26# what instructor-17 may read: enrollments with each one's progress, and no country27seen = platform.sql("select course_id, progress_pct from learning.enrollments", "instructor-17").to_arrow_table()28platform.connection.register("seen", seen)29print("cells of one learner:", count("from report where learners = 1"))30print("learners a cell of one names:", count("""from report as cell where learners = 1 and (select count(*) from seen31 where seen.course_id = cell.course_id and seen.progress_pct = cell.progress) = 1"""))32print("cells shown with the minimum:", count(f"from report where learners >= {minimum}"))3334# The minimum doesn't stop differencing. An enrollment that arrives alone in its course on its day, in a cell already35# shown, raises that cell by one in the next day's report, and the instructor sees which enrollment arrived.36# an enrollment alone in its course that day, whose country already has the minimum on earlier days37revealed = count(f"""from mine as m38 where (select count(*) from mine as o where o.course_id = m.course_id and o.day = m.day) = 139 and (select count(*) from mine as o where o.course_id = m.course_id and o.country = m.country and o.day < m.day) >= {minimum}""")40print("learners whose country the daily report reveals anyway:", f"{revealed} of {count('from mine')}")
python small-groups-difference.pyminimum group size: 11
cells in the report: 63
cells under the minimum: 51
cells of one learner: 6
learners a cell of one names: 3
cells shown with the minimum: 12
learners whose country the daily report reveals anyway: 92 of 482
Una celda de uno revela el país de su estudiante a cualquiera que pueda encontrar a ese estudiante, y el instructor puede hacerlo: al comparar el progreso medio de la celda con sus propias inscripciones, identifica exactamente a 3 estudiantes. El informe tiene 63 celdas, de las cuales 51 están por debajo del mínimo y 6 contienen un solo estudiante cada una.
Con el mínimo, se muestran 12 celdas, y ninguna de esas búsquedas funciona. El mínimo no impide la diferenciación. Una inscripción que llega sola en su curso ese día, a una celda que ya se muestra, aumenta esa celda en uno en el informe del día siguiente, y el instructor ve qué inscripción llegó. Eso revela el país de 92 of 482 estudiantes.
La diferenciación, es decir, comparar informes consecutivos, es el ataque que Denning, Denning y Schwartz llamaron rastreador. Demostraron que "el compromiso de conjuntos de consulta pequeños casi siempre puede lograrse con la ayuda de fórmulas características llamadas rastreadores" (Denning et al., 1979).
Snowflake, que aplica un tamaño mínimo de grupo en su motor, afirma que sus políticas "no garantizan que un actor malintencionado no pueda usar consultas deliberadas para obtener datos potencialmente sensibles" (políticas de agregación de Snowflake). Frente a la diferenciación, recomendamos el ruido, como en la privacidad diferencial (Dwork and Roth, 2014), en lugar de umbrales más altos, y Privacy Engineering for Data Teams lo trata.
Regla práctica: Oculta todo grupo informado por debajo del mínimo en governance/enforcement.toml, y trata el mínimo como protección contra la búsqueda de una persona, nunca contra la diferenciación. No desgloses un informe por un atributo que su lector no puede leer, enviado a un lector que sí puede ver las filas detrás de él: el informe del instructor por país es una tabla de búsqueda de países. Elimina el desglose, o publícalo solo después de haberlo vuelto ruidoso.
Entrega las mismas políticas a un motor que las haga cumplir
En producción, la imposición de las políticas debe residir en el motor al que consultan todas las herramientas, porque el principio de mediación completa de Saltzer y Schroeder sostiene que "todo acceso a todo objeto debe verificarse en cuanto a su autoridad" (Saltzer and Schroeder, 1975), y una política que se aplica en una herramienta y no en otra incumple ese principio. Trino, un motor SQL distribuido de código abierto, puede tomar su control de acceso de Open Policy Agent (OPA) mediante un complemento, y el capítulo 5 dio a las solicitudes de la plataforma la forma de las del complemento para que una misma política sirviera a ambos. Trino 484 ofrece control de acceso basado en archivos, en OPA y en Ranger, y ninguno para Cedar (Trino 484, Security).
El complemento hace a OPA preguntas separadas en URI separadas (Trino 484, OPA access control):
- Si se permite una operación, como
SelectFromColumns, respondida con un booleanoallow. - Filtros de filas,
GetRowFilters, para una tabla. OPA responde con una lista de{"expression": ...}, y cada expresión "se comporta esencialmente como una cláusula WHERE adicional". El URI es opcional, y Trino no aplica ningún filtrado de filas cuando no está configurado. - Máscaras de columna,
GetColumnMask, para una columna, o para un lote de columnas enopa.policy.batch-column-masking-uri. "Solo puede devolverse una máscara de columna para una columna dada."
Los nombres de las operaciones y el lugar donde cada solicitud pone su tabla o columna están en el código fuente del complemento en la etiqueta 484 (OpaAccessControl.java, OpaHighLevelClient.java). La política de máscaras por lotes de la documentación lee filterResources[i].catalogName, mientras que su propio ejemplo de solicitud anida esos campos bajo .column, por lo que tal como está impresa no coincidiría. Las solicitudes construidas con esas formas llegan a su política:
1"""Builds requests in the shape Trino 484's OPA plugin sends, and runs them through the platform's policy. The prose's2points rest on the allow lines, which the example asserts are False, and on the GetRowFilters and GetColumnMask lines."""3import json45from lib import metadata, policy6from lib.enforce import row_filter78# The platform's policy, with a support agent added before anyone set their region (chapter 5's missing-region case).9data = policy.data_document()10data["platform"]["users"]["agent-new"] = {"groups": ["support"]}11rego = policy.interpreter(data=data)12described = metadata.load()131415def trino_request(user: str, operation: str, resource: dict | None = None) -> dict:16 """A request in the shape Trino 484's OPA plugin sends (OpaAccessControl, OpaHighLevelClient)."""17 action = {"operation": operation} | ({"resource": resource} if resource else {})18 return {"context": {"identity": {"user": user, "groups": []}, "softwareStack": {"trinoVersion": "484"}}, "action": action}192021# Trino asks `allow` about every operation: ExecuteQuery before any query runs, AccessCatalog for each catalog it names.22for operation, resource in [("ExecuteQuery", None), ("AccessCatalog", {"catalog": {"name": "platform"}})]:23 allowed = policy.decide(trino_request("agent-a05", operation, resource), rego)["allow"]24 # allow admits only SelectFromColumns, so Trino's checks before any query are denied25 assert allowed is False26 print(f"allow, {operation}, agent-a05:", allowed)2728# GetRowFilters names a table. The policy's row_filters rule on its own skips `allow` and its missing-attribute guard,29# so for agent-new it returns no filter, which Trino reads as no filtering. The answer comes from the decision instead,30# for the same read asked as SelectFromColumns: its filters in Trino's SQL, or a filter that keeps no rows.31for user, schema, table in [("agent-a05", "support", "tickets"), ("instructor-17", "learning", "reviews"),32 ("agent-new", "support", "tickets")]:33 request = trino_request(user, "GetRowFilters", {"table": {"catalogName": "platform", "schemaName": schema, "tableName": table}})34 print(f"GetRowFilters, {user}, {schema}.{table}, the rule alone:",35 json.dumps(policy.evaluate(rego, "data.platform.access.row_filters", request)))36 decision = policy.decide(policy.request(user, f"{schema}.{table}", []), rego)37 columns = {c.name: "" for c in described[f"{schema}.{table}"].columns.values()}38 # no table alias: Trino applies the filter to the table itself, as a WHERE clause on it39 filters = [{"expression": row_filter(rule, columns, table=None).sql("trino")} for rule in decision["row_filters"]]40 # a denied read gets a filter that keeps no rows41 print(f"GetRowFilters, {user}, {schema}.{table}, answered:", json.dumps(filters if decision["allow"] else [{"expression": "false"}]))4243# GetColumnMask names one column, under action.resource.column. The policy reads the columns of a SelectFromColumns44# request instead, so it masks nothing here until the request is translated.45column = {"catalogName": "platform", "schemaName": "crm", "tableName": "learners", "columnName": "email", "columnType": "varchar"}46decision = policy.decide(trino_request("analyst-1", "GetColumnMask", {"column": column}), rego)47print("GetColumnMask as sent, analyst-1, crm.learners.email:", json.dumps(decision["column_masks"]), decision["reasons"][0])48translated = policy.request("analyst-1", "crm.learners", [column["columnName"]])49print("GetColumnMask translated, analyst-1, crm.learners.email:", json.dumps(policy.decide(translated, rego)["column_masks"]))
python trino-requests.pyallow, ExecuteQuery, agent-a05: False
allow, AccessCatalog, agent-a05: False
GetRowFilters, agent-a05, support.tickets, the rule alone: [{"column": "support_region", "equals": "emea"}]
GetRowFilters, agent-a05, support.tickets, answered: [{"expression": "support_region = 'emea'"}]
GetRowFilters, instructor-17, learning.reviews, the rule alone: [{"column": "course_id", "in": [2, 75, 80, 87, 103, 134]}]
GetRowFilters, instructor-17, learning.reviews, answered: [{"expression": "course_id IN (2, 75, 80, 87, 103, 134)"}]
GetRowFilters, agent-new, support.tickets, the rule alone: []
GetRowFilters, agent-new, support.tickets, answered: [{"expression": "false"}]
GetColumnMask as sent, analyst-1, crm.learners.email: {} GetColumnMask is not an operation this policy allows
GetColumnMask translated, analyst-1, crm.learners.email: {"email": "pseudonymize"}
Si se apuntara a Trino sin cambios la política, la política denegaría las comprobaciones que Trino hace primero, porque su allow solo admite SelectFromColumns. allow es falso para ExecuteQuery, que Trino consulta antes de ejecutar cualquier consulta, y para AccessCatalog.
La regla row_filters no evalúa la operación, así que responde GetRowFilters, pero por sí sola omite allow y la protección de atributos ausentes del capítulo 5. Para agent-new, un agente de soporte que todavía no tiene región, devuelve [], que Trino interpreta como ausencia de filtrado. Por tanto, la respuesta debe provenir de la decisión para la misma lectura, consultada como SelectFromColumns: sus filtros, escritos en SQL de Trino por el mismo row_filter que usa la reescritura o, cuando deniega la lectura, [{"expression": "false"}], que no devuelve filas.
GetColumnMask nombra la columna en action.resource.column, mientras que la política lee las columnas de una solicitud SelectFromColumns, así que tal como se envía no enmascara nada y la política rechaza la operación; traducida, obtiene pseudonymize. En producción, esas traducciones, la comprobación allow y el SQL de Trino deben residir en un módulo Rego junto a la política, para que OPA pueda responder a Trino directamente. Aquí no se ejecuta ningún servidor OPA, así que el código muestra solo lo que ese módulo debe devolver. Una pieza más se asigna directamente a Trino: el filtro de consentimiento lee crm.learners, que el asistente no puede leer, y Trino permite que un filtro lleve un identity con el que ejecutarse, "de modo que un filtro pueda apuntar a una columna que el usuario solicitante no puede ver".
Desde la versión 1.9.0, la API de compilación de OPA también puede escribir cláusulas SQL WHERE a partir de una política mediante evaluación parcial (OPA v1.9.0, Data filtering with OPA), pero requiere un servidor OPA, que los ejemplos no ejecutan.
Regla práctica: Coloca la imposición de las políticas en el motor al que consultan todas las herramientas, con una sola política para ella y para cualquier reescritura como la de este capítulo. Con Trino, responde a cada operación sobre la que pregunte el complemento, configura los URI de filtros de filas y de máscaras de columna (sin ellos no se aplica ningún filtro ni máscara) y devuelve filtros de filas solo desde una decisión que permita la lectura. Construye las pruebas a partir de las formas de solicitud del código fuente del complemento, no de las políticas de ejemplo de su documentación.
Consultar en nombre de alguien
Un asistente que responde preguntas desde el almacén es un usuario más de la capa, con una decisión que tomar: ¿con qué identidad realiza su consulta? El asistente de cursos, assistant-1, tiene su propio acceso, limitado a las reseñas de los alumnos que han dado su consentimiento. Cuando responde a una persona, debe consultar en nombre de esa persona, para que la respuesta contenga exactamente lo que ella podría leer por sí misma. Las directrices de OWASP para aplicaciones con modelos de lenguaje dicen lo mismo: "Implementa la autorización en los sistemas posteriores en lugar de confiar en que un LLM decida si una acción está permitida o no" (OWASP LLM06:2025). El asistente en sí pertenece a Data Assistants in Practice; esta sección trata de sus consultas.
instructor-17 le pregunta al asistente cómo se ven las reseñas de sus cursos, y el asistente escribe una consulta. La herramienta toma al usuario de la sesión autenticada, nunca del modelo ni de la conversación, así que ningún prompt puede cambiar en nombre de quién se ejecuta la consulta:
1"""Runs the course assistant's review query as instructor-17 and as assistant-1, through a tool that takes the user from2the signed-in session. The prose's point rests on the reviews-behind-it lines for each user."""3from lib import policy4from lib.catalog import open_catalog5from lib.enforce import Enforcer67platform = Enforcer(open_catalog(["crm.learners", "learning.reviews"]))8courses = set(policy.data_document()["platform"]["instructor_courses"]["17"]) # instructor-17's own courses91011def query_tool(session_user: str):12 """The tool the course assistant calls to query the warehouse. The model writes the SQL; the user it runs as comes13 from the signed-in session, never from the model or the conversation."""14 # the user is the session's; the SQL is all the model contributes15 return lambda sql: platform.sql(sql, user=session_user).fetchall()161718# instructor-17 asks the assistant how their courses' reviews look. The assistant writes this query.19question = "select course_id, count(*) as reviews, round(avg(rating), 2) as rating from learning.reviews group by all"20for runs_as in ["instructor-17", "assistant-1"]:21 answer = query_tool(runs_as)(question)22 print(f"run as {runs_as}, courses in the answer:", len(answer))23 print(f"run as {runs_as}, reviews behind it:", sum(reviews for _, reviews, _ in answer))24 # each answer row is (course, reviews, rating), so row[0] is the course25 mine = [row for row in answer if row[0] in courses]26 print(f"run as {runs_as}, instructor-17's reviews behind it:", sum(reviews for _, reviews, _ in mine))
python assistant-on-behalf.pyrun as instructor-17, courses in the answer: 6
run as instructor-17, reviews behind it: 69
run as instructor-17, instructor-17's reviews behind it: 69
run as assistant-1, courses in the answer: 130
run as assistant-1, reviews behind it: 436
run as assistant-1, instructor-17's reviews behind it: 7
La identidad con la que se ejecuta la consulta decide lo que la respuesta cubre. La identidad propia del asistente es incorrecta en ambos sentidos: muestra al instructor lo que no puede ver, y oculta lo que sí puede. Ejecutada como instructor-17, la respuesta cubre sus 6 cursos y 69 reseñas. Ejecutada como el asistente, cubre 130 cursos, la mayoría de otros instructores, y solo 7 de las reseñas propias del instructor, aquellas cuyos autores consintieron el entrenamiento de IA. Lo mismo ocurre con la recuperación: un asistente que se apoya en texto gobernado necesita "almacenes de vectores e incrustaciones que tengan en cuenta los permisos" (OWASP LLM08:2025).
Regla práctica: Ejecuta las consultas de un asistente en nombre de la persona a la que responde, tomando esa identidad de su sesión autenticada, y deja que la capa aplique la decisión de esa persona. Usa la identidad propia del asistente solo para el trabajo que realiza sin atender a nadie en particular, como un resumen nocturno de reseñas con consentimiento para las páginas de los cursos, y registra ambas identidades en el registro de auditoría. Quien construya el conjunto de entrenamiento del asistente consulta en su propio nombre, con el propósito ai-training, como lo hace el capítulo 9.
Qué falla en producción
Una capa de control falla al dejar pasar una lectura que nadie probó, y la mayoría de estos fallos parecen respuestas correctas:
SELECT *se cuela en una tabla que falta en el esquema.qualifydeja la estrella sin expandir y no lanza ningún error. Deniega toda tabla que el catálogo no contenga y reconstruye el esquema cada vez que cambie el catálogo.- Los agregados filtran grupos pequeños. Una celda de uno identifica a su persona, y las diferencias entre informes identifican a personas de celdas que superan cualquier mínimo, como mostró el ejemplo del informe. Establece el mínimo y elimina los desgloses por atributos que el lector no puede leer.
- Las uniones y las copias devuelven columnas enmascaradas. Un pipeline con acceso completo, como el que escribe
marketing.audience, copiaemailen una tabla protegida solo por su propia clasificación. Sin clasificación, la copia queda oculta para todos, como mostró la prueba de quién ve qué; si se clasificainternalpor error, se muestra a cualquiera que pueda leer la tabla. El capítulo 4 propaga las clasificaciones a lo largo del linaje para detectarlo. Las columnas sin enmascarar también se reidentifican mediante uniones: Sweeney halló que el 87% de la población de EE. UU. probablemente es única con el código postal, el sexo y la fecha de nacimiento, en datos del censo de 1990 (Sweeney, 2002), y Golle, al contar de nuevo, halló el 61% con los mismos datos de 1990 y el 63% con los de 2000 (Golle, 2006). Rocher y colegas estiman, a partir de un modelo ajustado a datos censales, que 15 atributos demográficos harían único al 99.98% de las personas de Massachusetts (Rocher et al., 2019). - Las lecturas directas de archivos eluden la reescritura.
read_parquet, una ruta enFROMy las funciones de tabla leen datos sin nombrar ninguna tabla. Deniégalos en la reescritura, y desactivaenable_external_access, que DuckDB luego no vuelve a activar: "Cannot enable external access while database is running".lock_configurationmantiene todos los demás ajustes tal como los dejó la capa; establécelo una vez que la conexión de la capa esté completamente configurada (Securing DuckDB), no al crearla, ya que el capítulo 8 inicia el registro de consultas de DuckDB después. Quien pueda leer los archivos del almacén en el almacenamiento no necesita SQL, así que los permisos de almacenamiento forman parte del control. - La capitalización de los identificadores decide qué nombre coincide. Una capa que comparara nombres sin normalizarlos permitiría que
"LEARNERS", que DuckDB resuelve comolearners, llegue a la tabla sin procesar, como mostró la primera sección. Normaliza con el dialecto del motor que ejecuta la consulta antes de comparar cualquier nombre. - Los mensajes de error muestran valores. Los errores de conversión de DuckDB incluyen el valor. La reescritura de tablas lo convierte en uno enmascarado, y el control de cada columna mantiene fuera de alcance las filas descartadas, pero el mensaje sigue llegando al usuario si nada lo detiene. Devuelve un error genérico en el límite del servicio, como hace
lib.enforce.answer, y registra el mensaje del motor solo donde lo lee el equipo de plataforma, aparte del registro de auditoría, que el capítulo 8 mantiene libre de valores. PostgreSQL advierte que los planes y los tiempos siguen siendo canales encubiertos incluso detrás de una barrera de seguridad (PostgreSQL 18, Rules and Privileges). - DuckDB no es una frontera de seguridad. «DuckDB ejecuta SQL con los privilegios completos del usuario que lo ejecuta, de forma muy similar a una shell o a un intérprete de scripts» (Securing DuckDB). Una reescritura dentro del mismo proceso protege los datos solo mientras los usuarios no puedan llegar a DuckDB por ninguna otra vía. Trata la capa de este capítulo como un modelo probado de lo que impone un motor como Trino, y aplica las restricciones allí en producción.
Lo que decidió este capítulo
- La imposición de la política reemplaza tablas, no columnas. Cada tabla del catálogo se convierte en una subconsulta generada a partir de la decisión; reescribir las referencias a columnas se conserva solo para mostrar que filtra información.
- La capa falla cerrada. Sus fuentes son una lista blanca de tablas del catálogo, CTE en alcance y subconsultas. Deniega las funciones con efectos secundarios, los parámetros y cualquier cosa que no sea una única consulta. Las columnas que una consulta no lee se tipan como
NULL, y las que sí lee quedan condicionadas a los filtros de fila. - Los usuarios reciben un único error genérico de
answer, y el mensaje de DuckDB se envía al equipo de plataforma. - Las máscaras son SQL en un solo lugar. La política nombra las máscaras;
lib.enforceescribe su SQL. Los seudónimos se generan con una clave secreta que solo conoce la capa, pasada como parámetro. - Los filtros de fila se construyen a partir de los datos, con los valores como literales. El consentimiento es un semi-join que la capa ejecuta con su propio acceso, y un consentimiento desconocido cuenta como ausencia de consentimiento.
- Quién ve qué se prueba como consultas: los casos del capítulo 5 se ejecutan a través de la capa en cada cambio.
- Los informes ocultan los grupos por debajo del tamaño mínimo de grupo, 11 en
governance/enforcement.toml, y no desglosan por atributos que sus lectores no pueden leer. - Los asistentes consultan como la persona a la que responden, con la identidad tomada de la sesión.
- En producción, el motor impone la política: Trino con OPA, a partir de la misma política, con ambas URI configuradas y los filtros de fila respondidos solo desde una decisión permitida. Una capa es tan segura como sus pruebas.
Este capítulo, en esta edición
Edición 2026.11.31Ejemplos verificados el 19 de nov de 2026Superan la prueba 16 de 16 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.31.