《AI Agent 技术原理与架构·运行时、协议与系统架构》4.3 能力边界与逃逸面

Agent 的能力不是一条条权限,而是一张图:每个动作需要某些能力,执行后还授予新能力。实验演示 debug 权限如何沿 inspect_pid→dump_core→write_crontab 链条升级到 remote_exec,并给出两个工具:计算可达能力闭包,以及用穷举求覆盖任务意图的最小初始权限集。结论是初始权限要大得能干活、小得无逃逸。

以下能力图、动作与授予链均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。debug→remote_exec 的升级链是讲解用的模型,真实系统以实际工具的权限语义为准,但"组合动作可以走出初始权限之外的闭包"这一条不变。

4.2 讲了系统调用怎么开放。这一节看更高一层:Agent 的能力边界。系统调用隔离管"内核层面能做什么",能力边界管"业务层面能做什么"——两者都是逃逸面,但量纲不同。

能力边界最容易犯的错,是以为权限是"一条条加的":给了 debug,就是只多了一个 debug。实际上能力是一张图:每个动作需要某些能力,执行后还可能授予新能力。组合动作可以走出权限升级链,让初始的一小撮权限膨胀成远超任务需要的闭包。 这一节给出计算闭包、检测逃逸、求最小初始权限的三个工具。

能力是一张图,不是一张表

把每个动作建模成三元组:执行它需要什么能力(requires),执行后授予什么新能力(grants)。

动作requiresgrants
read_fileread(无)
inspect_piddebugmemory_read
dump_corememory_readdisk_write_local
write_crontabdisk_write_localremote_exec

这张图暗藏一条升级链:debug → inspect_pid → memory_read → dump_core → disk_write_local → write_crontab → remote_exec。初始只有 debug,但四个动作组合下来,最终拿到 remote_exec(远程执行)。 这就是逃逸面的来源:单个动作看起来安全,链条把它们接起来就危险。

为什么逃逸是"闭包"问题

从初始权限出发,能通过动作链条到达的所有权限,叫可达能力闭包(closure)。逃逸面 = 闭包 − 任务意图。

初始权限闭包任务意图逃逸面
read, debugread, debug, memory_read, disk_write_local, remote_execreaddisk_write_local, memory_read, remote_exec, debug

给"只需要读文件"的任务配了 debug,闭包一路膨胀到 remote_exec。任务想要的只有 read,系统实际给到的是近乎全能的闭包。 这就是"最小权限"要解决的问题:初始权限要小到闭包不含逃逸,又大到闭包覆盖任务意图。

最小实验:闭包、逃逸与最小权限

实验提供三个工具:closure 计算可达能力闭包、escalation 求逃逸面、minimum_permissions 用穷举求覆盖任务意图的最小初始权限集。

# file: agp_lab/capability_bounds.py | write
# tier: 3
# verify: python3 -m unittest tests.test_capability_bounds
"""能力边界与逃逸面:能力图、权限升级与最小权限。

Agent 的能力不是一条条权限,而是一张图:每个动作需要某些
能力,执行后还可能授予新能力。组合动作可以走出权限升级链,
让初始的一小撮权限膨胀成远超任务需要的闭包。

本模块做三件事:
1. 计算可达能力闭包(权限升级路径);
2. 检测超出任务意图的逃逸面;
3. 用穷举求出覆盖任务意图的最小初始权限集。
"""
from __future__ import annotations

from dataclasses import dataclass
from itertools import combinations
from typing import Any


@dataclass(frozen=True)
class Action:
    name: str
    requires: frozenset[str]
    grants: frozenset[str]


ACTIONS: list[Action] = [
    Action("read_file", frozenset({"read"}), frozenset()),
    Action("inspect_pid", frozenset({"debug"}), frozenset({"memory_read"})),
    Action("dump_core", frozenset({"memory_read"}), frozenset({"disk_write_local"})),
    Action("write_crontab", frozenset({"disk_write_local"}), frozenset({"remote_exec"})),
]


def closure(initial: set[str], actions: list[Action] | None = None) -> set[str]:
    """计算从初始权限出发的可达能力闭包。"""
    actions = actions or ACTIONS
    reachable = set(initial)
    changed = True
    while changed:
        changed = False
        for action in actions:
            if action.requires <= reachable and not (action.grants <= reachable):
                reachable |= action.grants
                changed = True
    return reachable


def escalation(initial: set[str], intended: set[str]) -> set[str]:
    """返回超出任务意图的逃逸能力。"""
    return closure(initial) - intended


def minimum_permissions(intended: set[str], all_abilities: set[str]) -> set[str]:
    """覆盖任务意图的最小初始权限集(能力全集较小时用穷举)。"""
    abilities = sorted(all_abilities)
    for size in range(0, len(abilities) + 1):
        for combo in combinations(abilities, size):
            if intended <= closure(set(combo)):
                return set(combo)
    return set(abilities)


def demo() -> dict[str, Any]:
    intended = {"read"}
    all_abilities = {"read", "debug", "memory_read", "disk_write_local", "remote_exec"}
    return {
        "closure_read_debug": sorted(closure({"read", "debug"})),
        "closure_read": sorted(closure({"read"})),
        "escalation_debug": sorted(escalation({"debug"}, intended)),
        "minimum_for_read": sorted(minimum_permissions(intended, all_abilities)),
    }


if __name__ == "__main__":
    for key, value in demo().items():
        print(f"{key}: {value}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.capability_bounds

输出:

closure_read_debug: ['debug', 'disk_write_local', 'memory_read', 'read', 'remote_exec']
closure_read: ['read']
escalation_debug: ['debug', 'disk_write_local', 'memory_read', 'remote_exec']
minimum_for_read: ['read']

四行输出对应四件事:

  1. closure_read_debug:从 {read, debug} 出发,闭包是五个能力。debug 触发了整条升级链:inspect_pid(给 memory_read)→ dump_core(给 disk_write_local)→ write_crontab(给 remote_exec)。
  2. closure_read:从 {read} 出发,闭包只有 read。没有 debug,链条一步都走不动——read_file 不授予任何新能力。
  3. escalation_debug:逃逸面是 {debug, disk_write_local, memory_read, remote_exec}——除了 read 本身,初始的 debug 加上链条推出来的三个,全部超出任务意图。
  4. minimum_for_read:覆盖"只需要 read"的最小初始权限集就是 {read}。不需要 debug。

两个值得点破的细节:

  • 最小权限的答案是"去掉那一步"。 任务是只读,就只给 read;{read} 的闭包正好是 {read},零逃逸。问题从来不是"该加什么权限",而是"该删掉什么引发链条的初始权限"。
  • 闭包计算是单调收敛的。 closure 用迭代直到不动点:每次发现"requires 已满足且 grants 未达"就扩展,直到没有动作能再授予新能力。这保证闭包是确定的、可审计的——逃逸面不是靠直觉,而是算出来的。

能力边界的管理,最终要落在"每个任务一个最小能力集"。最小能力集的确定不该靠拍板,而要靠工具:先穷举能力全集(能力少时可行,见实验的 minimum_permissions),能力多时用启发式或模板。

任务类型最小能力集示例常见错误
只读问答read给了 read + debug
代码修改read + write给了 remote_exec
运维处置read + restart给了整个 host 权限

还有一个重要的边界:能力闭包不只是权限升级,还包括信息泄漏。 一个只有 read 权限的任务,如果某个工具的 grants 里带了 memory_read,它就能读到不该读的进程内存——这同样是逃逸,只是泄的是数据而不是操作权。所以能力边界评估要同时看"能做什么"和"能看到什么"两个维度。

能力图本身也要版本化。工具升级(比如 dump_core 的 grants 从 disk_write_local 扩到 disk_write_any)会改变闭包;能力图变更要触发闭包重算与逃逸重审,就像依赖图变更触发不变量检查一样(见 1.3)。

能力图要回答审计问题,而不仅仅是提供运行时权限。 一个 Agent 被攻击后渗透了多远,靠能力图快速评估:它持有哪些能力、这些能力能触达哪些资源、升级路径有几条。能力图因此要有版本和差异——今天加了什么能力、因为哪个工具变更,都该可回溯。

审计场景能力图提供没有它的后果
安全事件复盘可达资源清单攻击面靠猜
权限最小化未使用能力列表权限只增不减
工具升级评估闭包变化对比逃逸悄悄扩大

最小能力集的落地,逆着"能力越多越省事"的惯性。 给任务加能力很容易,收回很难——一旦有任务用上了,回收就要改它的逻辑。所以能力变更要走"申请-审计-生效"的流程,而不是开发时随手加。最小能力不是一次审出来的,是每次加能力时审出来的。

能力边界的模型化工具是能力有向图:节点是"能力",边是"能力之间可组合或可升级"的关系。最小能力集不是简单列表,而是这个图上的一棵子树——给任务一个能力,相当于授予它通向其他能力的路径。审计时看的不只是"给过什么能力",而是"从这些能力能长出什么"。

图视角问题行动
节点有哪些能力清理未用能力
边可组合出什么剪断危险组合
入度/出度能力聚集点高聚集点是攻击面

能力图的另一个用途是"事故归因"。 一个任务出事,从它持有的能力图快速枚举"它理论上能做什么",判断是能力被滥用(它本不该有这个能力)、还是能力设计本身的问题(这个能力隐含了过度权限)。归因分清这两类,才能决定是收权限还是改能力定义。

能力边界与工具契约(5.1)的接口要明确:能力边界决定"Agent 能否调用这个工具",工具契约决定"调用时参数怎么校验"。一个任务有 read 能力但没有 write 能力,它调用一个写工具应该被能力层拒绝,而不是工具层——工具层只校验参数合法性,能力层才判断"这个 Agent 有没有资格"。两层职责不清,权限就漏在缝隙里。

层判断拒绝时机
能力层有没有资格调用前
契约层参数合不合法调用时
执行层能不能做成执行中

最小能力集还有一个动态视角:任务运行中能力需求会变化。 一个任务开始只需 read,进行到中途要写临时文件——此时是"启动前授满"(给 read+write,违背最小),还是"运行中动态授予"(能力按需加,需授权机制)?动态授予更符合最小集,但要防"任务自己给自己加能力"——动态授予必须走运行时授权,而不是任务自行扩展。能力是静态最小 + 动态受控授予,缺一个都会失衡。

能力边界的运维节奏:定期收敛。 能力清单会随时间膨胀——新功能加能力、旧功能没人删。定期(如每迭代)清点"实际用到的能力",未使用的从最小集里收回。能力收敛与代码清理一样,是防膨胀的例行维护。 让"当前能力清单"可审计、可对比(上次清点之后加了什么),收敛才能执行下去。

收敛节奏动作效果
每次加能力申请-审计-生效防膨胀
每迭代清点未用能力定期收敛
安全事件后全量复审收窄攻击面

架构判据

能力边界是否合格,用五条判据检查:

判据合格的样子不合格的样子
能力图建模每个动作声明 requires/grants权限散落,链条不可见
闭包可算初始权限的可达闭包可计算逃逸面只能靠猜
零逃逸闭包 ⊆ 任务意图闭包超出意图,有升级链
最小权限初始权限恰好覆盖意图初始权限过大触发链条
审计闭环闭包计算进发布检查能力图更新不重新审计

判据第三条"零逃逸"是硬门槛:闭包超出任务意图,就是逃逸面,不管链条上的单个动作看起来多安全。 判据第五条提醒:能力图不是写一次就完,每加一个动作(grants 变了),闭包要重算、逃逸要重新审计。

小结

  • 能力是一张图:每个动作需要某些能力,执行后授予新能力;组合动作可走出升级链。
  • 可达能力闭包是逃逸面的精确量:逃逸 = 闭包 − 任务意图。
  • 最小初始权限恰好覆盖意图、闭包零逃逸;问题常在于该删掉触发链条的初始权限。
  • 闭包计算单调收敛、可审计;能力图更新要重新审计闭包。

阅读导航:上一节:4.2 文件系统、网络与系统调用隔离 · 下一节:5.1 工具契约:schema、错误与版本 。

常见错误与边界

  1. 把权限当"一条条加的"。 权限是图不是表;debug 背后可能藏着一整条到 remote_exec 的链。
  2. 只审单个动作。 每个动作都安全,链条接起来就危险;要审闭包,不是审动作。
  3. 初始权限给太宽。 给"只需要读"的任务配 debug,闭包直接膨胀到远程执行。
  4. 能力图更新不重算闭包。 每加一个 grants 变化,逃逸面就变;要重新审计而不是沿用旧结论。
  5. 最小权限不等于"权限越少越好"。 权限少了任务会失败(比如该写文件的只有读);要恰好覆盖意图。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图