# 一个CTE名字，足以骗过text-to-SQL智能体的只读防护

> SQLGlot自称是转译器而非校验器，语法树上的安全规则，包括作用域解析，都得自己动手写。

原文: https://fdetimes.net/zh/guides/text-to-sql-agent-select-only-sqlglot/

SQLGlot 的 README 说得很直白：SQLGlot 是转译器，不是校验器。你打算拿来当安全关卡的工具，自己就声明从来不是为这件事设计的。想让它守住什么，就得自己在语法树上写规则。

为什么在提示词里叮嘱智能体还不够？SurrealDB 一篇关于智能体越狱的文章说得简短：系统提示词只是建议，不是围栏。text-to-SQL 智能体一旦接入客户的数据库，规则就必须放在模型够不着的那一层。

本指南在你的笔记本上搭建这一层：一个 Python 函数，接收一段 SQL 字符串，要么返回审核通过的查询，要么抛出错误。最终得到的防护只允许一条 SELECT 语句，只能查 `orders` 和 `customers` 两张表，不能调用陌生函数。你需要 Python 3、`pip install sqlglot`，以及大约一小时。

这里的代码是用于学习的精简版。请在 requirements 文件中锁定 sqlglot 版本，并把文末的六条测试查询当作标尺：每次升级后，部署前都要重新跑一遍。

## 为什么用解析而不是正则？

SQLGlot 是一个纯 Python 编写、没有其他依赖的解析器，能把 SQL 字符串转换成代码可以遍历的抽象语法树（AST）。DEV Community 上一篇关于安全 text-to-SQL 的指南正是这样建议的：把生成的查询解析成 AST 来检查语义，比如确认其中只有 SELECT。

正则只看得到字符。语法树能告诉你真实的结构：`orders` 这个词究竟是表名、列名还是字符串字面量。下面整套防护都建立在这个区别之上。

## 第 1 步：解析出错就拒绝，绝不猜测

README 提到，解析器检测到语法错误时会抛出 `ParseError`。这就是防护的第一个分支：不尝试修复，不重试，直接拒绝。你还要求恰好只有一条语句，以拦截 `SELECT 1; DROP TABLE orders` 这类输入。

```python
import sqlglot
from sqlglot import exp
from sqlglot.errors import ParseError

class Rejected(Exception):
    pass

def parse_single(sql: str) -> exp.Expression:
    try:
        statements = sqlglot.parse(sql, read="postgres")
    except ParseError as e:
        raise Rejected(f"解析错误：{e}")
    statements = [s for s in statements if s is not None]
    if len(statements) != 1:
        raise Rejected("必须恰好只有一条语句")
    return statements[0]
```

检查：调用 `parse_single("SELECT 1; SELECT 2")` 必须抛出 `Rejected`。这里用的是返回语句列表的 `sqlglot.parse`，而不是 README 示例中的 `parse_one`，因为防护需要统计语句数量。

## 第 2 步：只接受根节点为 SELECT 的语法树

解析器比较宽松，解析成功说明不了什么。第二条规则检查语法树本身：根节点必须是 SELECT，并且用 `walk` 遍历整棵树时，不能出现任何写数据的节点。

项目的 AST Primer 解释说，`find` 和 `find_all` 都构建在 `walk` 之上，因此要做最细粒度的控制，就用 `walk`。

```python
FORBIDDEN = (exp.Insert, exp.Update, exp.Delete,
             exp.Drop, exp.Create, exp.Command)

def require_select(tree: exp.Expression) -> None:
    if not isinstance(tree, exp.Select):
        raise Rejected(f"根节点是 {type(tree).__name__}，不是 SELECT")
    for node in tree.walk():
        if isinstance(node, FORBIDDEN):
            raise Rejected(f"禁止的节点：{type(node).__name__}")
```

`FORBIDDEN` 列表有意保持简短，因为“根节点必须是 SELECT”这条规则承担了大部分工作。

这么严格的根节点规则，也可能拦下 `UNION` 这类合法的读查询，具体取决于 sqlglot 如何为它们构建语法树。在测试集中加一条 `UNION` 查询，就能在你锁定的版本上确认结果。

过度拦截是有意为之：等客户确实需要时再放宽规则，不要提前放宽。

## 第 3 步：表白名单，以及 CTE 陷阱

README 里有个示例，用 `find_all(exp.Table)` 列出查询中的所有表，这自然成了白名单的起点。人人写出的第一版大致如下。

```python
ALLOWED = {"orders", "customers"}

def naive_tables(tree):
    cte_names = {c.alias_or_name for c in tree.find_all(exp.CTE)}
    for t in tree.find_all(exp.Table):
        if t.name in cte_names:
            continue  # 假定是 CTE，跳过
        if t.name not in ALLOWED:
            raise Rejected(f"表不在白名单中：{t.name}")
```

为什么要有 `cte_names`？AST Primer 提醒，`Table` 节点并不总是数据库里的表，因为公用表表达式（CTE）的名称也会以 `Table` 的形式出现。如果不跳过它们，所有合法的 `WITH` 查询都会被拦下。

但按名字跳过会留下漏洞。看一个构造的测试用例：智能体生成 `WITH salaries AS (SELECT * FROM salaries) SELECT * FROM salaries`。在 CTE 主体里，`salaries` 是真实的薪资表；上面的函数看到名字与 CTE 相同，三处出现全部放行。

**要点:** 两个名字相同，未必指向同一个东西；防护必须知道每个名字指向什么。

## 第 4 步：让 scope 模块判断哪些名字是真实的表

AST Primer 介绍了 scope 模块，这是一种能感知语义的遍历方式，知道每个名字引用的是什么：`build_scope` 会判断一个名字是物理表、CTE 还是子查询。这正是防护需要回答的问题。

```python
from sqlglot.optimizer.scope import build_scope

def check_tables(tree: exp.Expression) -> None:
    root = build_scope(tree)
    if root is None:
        raise Rejected("无法构建作用域")
    for scope in root.traverse():
        for name, source in scope.sources.items():
            if isinstance(source, exp.Table) and source.name not in ALLOWED:
                raise Rejected(f"表不在白名单中：{source.name}")
```

在每个作用域内，类型为 `exp.Table` 的来源是真实的表；类型为子作用域的来源是 CTE 或子查询，其主体会在循环的后续轮次中单独检查。注意 `root is None` 这个分支：无法构建作用域同样属于不确定，因此也以拒绝告终。

再跑一次 `salaries` 的例子：这次 CTE 主体应当被拒绝，因为在那里 `salaries` 是物理表，而不是 CTE 名称。

## 第 5 步：别忘了函数

SELECT 仍然可以通过函数调用做危险的事。据 hoop.dev 介绍，PostgreSQL 默认会把函数和存储过程的执行权限授予 public 角色，所以只读角色照样能调用函数。防护应当拦截解析器不认识的函数调用。

```python
def check_functions(tree: exp.Expression) -> None:
    for node in tree.find_all(exp.Anonymous):
        raise Rejected(f"函数不在白名单中：{node.name}")

def guard(sql: str) -> str:
    tree = parse_single(sql)
    require_select(tree)
    check_tables(tree)
    check_functions(tree)
    return tree.sql(dialect="postgres")
```

这一版经过简化，并且依赖一个需要你自行验证的假设：sqlglot 不认识的函数会变成 `exp.Anonymous` 节点。

下面的 `pg_sleep` 测试正是为了检验这个假设；如果它能通过，说明这项检查还不够。在生产环境中，应把它反过来改成函数白名单，例如只允许 `COUNT`、`SUM` 和 `DATE_TRUNC`，并在数据库层面收回执行权限。

## 收工前的六条测试查询

用 `guard` 跑这六条查询并记录结果。`SELECT id, total FROM orders` 必须通过。`DELETE FROM orders` 必须在第 2 步被拦截，`SELECT * FROM salaries` 必须在第 4 步被拦截。`salaries` 那条 CTE 查询必须被拦截，`SELECT pg_sleep(10)` 也一样；`SELEC * FRM` 这样的乱码字符串必须停在第 1 步或第 2 步。

最后一条给出的教训最重要。你不需要知道宽松的解析器会把乱码变成什么，因为每个不确定的分支都通向拒绝。最常见的错误恰恰相反：只拦截列出来的坏情况，其余一律放行。

今天就把这六条查询保存为 pytest 测试。任何一条结果出乎意料，都说明代码在某处对 sqlglot 构建语法树的方式做了错误假设；每次升级锁定的 sqlglot 版本后，也正是这些测试告诉你防护是否依然有效。

## 你的防护不是最后一道防线

SurrealDB 把问题讲得很清楚：如果数据库拒绝执行某条语句，智能体是怎么被骗着生成它的就不再重要。DEV Community 的指南同样建议，数据库用户只授予特定非敏感表的 SELECT 权限，并以只读连接作为最后一层防御。

即便这一层也有局限。PostgreSQL 关于 `SET TRANSACTION` 的文档说明，只读是一个高层概念，并不能阻止所有写盘操作。所以要叠加三层：AST 防护、最小权限角色、只读事务，并且不把其中任何一层当作唯一防线。

## 这项技能在客户现场是什么样子

在把 text-to-SQL 智能体接入客户数据库之前，先准备好一个问题的答案：智能体能碰哪些表？代码评审中的白名单文件、在 CI 里运行的攻击测试集、数据库角色的授权，都是别人可以核验的东西，系统提示词做不到这一点。

如果你正准备转向前线部署工程师（FDE）岗位，可以把这个防护和测试放到 GitHub 上，并在简历里写清它具体做了什么：拦截非 SELECT 语句、通过作用域解析 CTE、解析出错即拒绝。申请那些要让智能体接触真实客户数据的岗位时，这是一个值得带进面试的例子。

到客户现场的第一天，别先打开提示词。先要一份智能体真正需要的表清单，再让白名单和授权与这份清单严格一致。

**本周动手试试:**

- 安装 sqlglot，在 requirements 中锁定版本，复制本指南中的防护函数，跑一遍六条测试查询，包括名为 'salaries' 的 CTE
- 针对你的防护再写 10 条攻击查询，并保存为 pytest 测试
- 检查一个生产环境中运行的智能体的数据库角色：除了 SELECT 还有哪些权限，能调用哪些函数

## 信源

- [SQLGlot README (tobymao/sqlglot)](https://github.com/tobymao/sqlglot/blob/main/README.md)

- [SQLGlot AST Primer](https://github.com/tobymao/sqlglot/blob/main/posts/ast_primer.md)

- [Even a jailbroken LLM can't exceed its database permissions (SurrealDB)](https://surrealdb.com/blog/even-a-jailbroken-llm-cant-exceed-its-database-permissions-heres-how)

- [Safe Text-to-SQL: giving an agent database access without dropping tables or leaking PII (DEV Community)](https://dev.to/kowshik_jallipalli_a7e0a5/safe-text-to-sql-giving-an-agent-database-access-without-dropping-tables-or-leaking-pii-i47)

- [LangChain SQL agent on PostgreSQL: limiting what it can execute (hoop.dev)](https://hoop.dev/blog/langchain-sql-agent-on-postgresql-limiting-what-it-can-execute)

- [SET TRANSACTION (PostgreSQL documentation)](https://www.postgresql.org/docs/current/sql-set-transaction.html)
