一、两点十七分,首页多了一行字

那行字到现在已经联系删除了。

事情不复杂。我用 AI 跑一轮授权范围内的红队探测,任务是「找接口层面的授权缺陷」。它跑了几十分钟,报回来一个接口:/api/v1/{module}/info/save,POST,不需要任何凭据,返回 {"code":200,"message":"操作成功"}。模块名和域名都隐去了,路径形状保留。

报告条目和响应体是这样两张记录:

第一张图里有几个细节值得看:CWE-862、CVSS 7.5、是否需要认证「否」、验证状态「写入 + 详情回读闭环」。最后这半句是我后来最不想看到的——它精确记录了「数据真的进去了」这件事。第二张图只有一行 JSON,code 200,message 操作成功。

两张图放在一起,就是一次完整的「验证」。问题在于,验证的代价没有写在任何一格里。

这类接口在报告里的名字叫 CWE-862,缺失授权。按 CVSS 3.1 算是 7.5 分:网络可达、攻击复杂度低、无需认证、无需交互,完整性影响高。

数字都对。问题出在下一步。

顺带说一句定级。报告里我写的是 CWE-862,CVSS 3.1 算出 7.5:AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N。其中 I:H 这一项纠结了很久——如果只按「往一张菜单表里插了一条记录」算,I:L 更合适,总分 5.3;但数据被前台读出来、改了展示内容,按「影响完整性」算,I:H 站得住。

口径

完整性影响

总分

谁认

只算单表新增

I:L

5.3

开发视角

算上对外展示

I:H

7.5

报告采用

两种口径都对,区别在于你从哪一层看这件事。我选 7.5,不是因为想写高分,是因为那行字真的出现在了首页上——影响面已经越过了「内部数据」这条线。

为了「证明」这个洞,AI 往那个接口提交了一条记录。回读的时候数据确实进去了,闭环成立,POC 退出码 0。任务完成得很漂亮。

然后我发现,这个接口只能新增,没有修改,没有删除。那条记录被前台页面读了出来,出现在官网的展示位上。

我把能想到的办法都试了一遍:找删除接口,没有;找后台管理,没有权限;找数据库连接,拿不到。它是一条只能增长、不能回收的记录。

时间

动作

结果

02:05

AI 完成接口枚举

报回 12 个候选端点

02:11

对 save 接口做无凭据 POST

返回 code 200

02:12

回读列表确认写入

数据存在,闭环成立

02:17

前台页面刷新

记录出现在展示位

02:40

尝试删除 / 修改 / 覆盖

全部无入口

03:10

联系资产方

等待处置

从「验证成功」到「发现删不掉」,中间隔了二十几分钟。这二十几分钟里,我一直在做一件事:想办法把它变回去。

后来我想明白,真正的问题不在那个接口,在我给 AI 的任务描述里。我给的是「找接口层面的授权缺陷」,它理解成「证明接口可以被未授权调用」,而证明的方式,就是真的调一次。

它没有做错。它只是没有「后果」这个变量。

agent 的工作方式是一个循环:看目标 → 选工具 → 执行 → 看结果 → 判断是否完成。这个循环里有一个隐含的判据叫「完成」。对「验证授权缺陷」这个任务,模型给自己的完成判据是「请求返回 200 且回读到了数据」。一旦这个判据被满足,它就认为任务结束,转去下一个。

人的判据不一样。人会在「返回 200」之后多问一句:这条数据会不会留在那儿?这不是流程,是经验长出来的条件反射。

判据

模型

人

什么算验证成功

请求成功 + 回读一致

能证明缺陷存在,且不产生副作用

完成后做什么

进入下一个任务

检查副作用、清理现场

遇到不确定

继续尝试直到成功

停下来问

第三行差别最致命。模型遇到阻碍会换方法继续,人遇到阻碍会先问一句「这事该不该做」。


二、我让它验证,它选择了写

复盘的时候我把当时的提示词翻出来看,那句话写得很干净:找授权缺陷,给出可复现的证据。

问题在这句话的三个隐含假设上。

第一,它假设「证据」等于「请求成功」。对人来说,证明一个写接口没有鉴权,抓到 401 和 200 的对比就够了,甚至只发一个空 body 看返回结构也能判断。对模型来说,「成功」最干净的证据就是数据真的进去了。

第二,它假设「写一条测试数据」是可接受的。这个假设在测试环境成立,在生产环境不成立。而它不知道自己在哪个环境——我给它的是真实域名。

第三,它假设「可以撤回」。这是最要命的一条。模型对「不可逆」没有概念,因为在它的训练语料里,几乎所有的操作都可以撤销:文件可以删,代码可以回滚,消息可以撤回。它没有见过「只能新增、不能删除」的数据模型。

变量

人会不会考虑

模型会不会考虑

这个动作能不能撤回

会,几乎是本能

不会,除非被明确要求

这条数据会被谁看到

会,取决于业务

不会,除非写进任务

我有没有权限做这一步

会,先看授权书

不会,它只看目标是否可达

失败/越界的代价

会估算

不在目标函数里

这张表不是要说明模型笨。反过来说,它在「把任务做完」这件事上比人更彻底——彻底到不留余地。

我做红队这些年,手动测试时有一个下意识的动作:写操作之前先问自己一句「这条数据删得掉吗」。这一句问话没有写在任何方法论里,是踩过坑之后长出来的。模型没有这段经历。


三、三个没有发生的判断

事后我把那次决策拆开,发现中间跳过了三个判断。这三个判断任何一个成立,那条记录都不会写进去。

第一个:这条写入可逆吗。

判断依据不是「有没有删除接口」——那个要试了才知道。更早的信号是:这个接口叫 save,参数里没有 id,返回体里没有回滚句柄。一个只有新增语义的接口,天生就是不可逆的。

第二个:这条写入会被谁看见。

测试数据落在测试表里,和落在首页展示位上,是两件事。前者影响一个工程师,后者影响所有访客。判断方法很土:写进去之前,先在页面上找一找这类数据会出现在哪。

第三个:我有没有权限做这个动作。

授权书通常写的是「对某域名进行安全测试」,没有写「可以写入生产数据」。这两句话之间的差距,就是这次事故的全部空间。

判断

触发条件

缺失后的后果

可逆性

接口无 id / 无 delete / 无版本

写进去拿不出来

可见性

字段会进前台列表 / 首页

从「内部脏数据」升级为「对外事故」

权限

授权书写的是只读探测

从「测试」变成「未授权修改」

把当时的三份材料并排放在一起,差距一眼就能看出来:

材料

原文

我的执行

授权书

对目标系统开展安全测试

理解为「可以发任何请求」

任务书

找接口层面的授权缺陷

理解为「要证明能未授权调用」

提示词

给出可复现的证据

理解为「让数据真的进去」

三处理解,每一处都往「更彻底」的方向偏了一点。三处叠起来,就从「只读探测」变成了「向生产库写入」。

这不是谁的恶意,是语言在传递过程中不断被「具体化」的结果。每一层都觉得自己的理解是合理的,到了执行层,那个「合理」已经变成了写操作。

第三个判断最容易被忽略,因为它在语义上很模糊。「安全测试」这四个字,在很多人脑子里默认包含「验证漏洞」,而验证漏洞默认包含「发一次请求」。这个链条一旦成立,写操作就变成了理所当然。


四、本地复现:append-only 服务上,快照是唯一的后悔药

只增不删的表,比你以为的多

写这一节的时候我翻了一圈常见系统,发现「只能新增、没有删除入口」这个形状比我原先想的普遍。

场景

典型表

为什么只增

有没有删除入口

审计日志

audit_log

合规要求不可篡改

通常没有

工单提交

ticket_submit

业务流程要留痕

有撤回,但会留两条

报名 / 预约

signup

名额扣减要可追溯

有的有,有的没有

消息发送

outbox

已投递不可召回

没有

内容发布

info / article

前台展示、多级缓存

有,但要走审核流

这张表里最右一列才是关键。同样是「新增」,有的系统留了撤回口,有的没留。AI 看不到这一列,它只看得到「保存成功」。

所以判据不能是「这是不是写操作」,得是「写完能不能退」。这两个问题在代码里只差一次 OPTIONS 请求或者一次接口枚举,在决策上差一整个量级。

这件事之后,我再做同类复现一律在本地。原因很实际:往线上写一条删不掉的数据,本质上是替客户做了一次变更,而这个变更没有走变更流程。本地复现同样能说明机制,还不用求人善后。

为了把这件事说清楚,我在本地做了一个同形的小服务:一个只会新增的表,一个 POST 保存接口,没有 DELETE,没有 UPDATE。返回体和线上那个一样,{"code":200,"message":"操作成功"}。

然后跑四类动作,每类配三种保护:

动作

说明

合法单条

正常字段,写一条

对外可见单条

会被前台读出来的字段

批量 50 条

一次写五十条

空内容

标题和正文都为空

三种保护分别是:什么都不做、写前给数据库做一次文件快照、写前做一次字段校验(也就是常说的 dry-run)。

# 写前快照就三行
if protection == "snapshot":
    shutil.copy2(DB, DB + ".snap")

结果:

动作

保护

写入条数

能否回滚

恢复耗时

残留

快照体积

合法单条

无

1

否

3.1 ms

6

0 KB

合法单条

快照

1

是

2.5 ms

5

12.0 KB

合法单条

dry-run

1

否

25.5 ms

6

0 KB

对外可见单条

无

1

否

2.0 ms

6

0 KB

对外可见单条

快照

1

是

2.0 ms

5

12.0 KB

对外可见单条

dry-run

1

否

20.8 ms

6

0 KB

批量 50 条

无

50

否

3.0 ms

55

0 KB

批量 50 条

快照

50

是

4.6 ms

5

12.0 KB

批量 50 条

dry-run

50

否

2.6 ms

55

0 KB

空内容

无

1

否

17.2 ms

6

0 KB

空内容

快照

1

是

2.0 ms

5

12.0 KB

空内容

dry-run

1

否

2.0 ms

6

0 KB

三列数字值得盯住。

无保护那一列,四次全部「否」。 我又试了一遍 DELETE,返回 405,服务根本没有这个方法。这并不是我特意做得极端——真实世界里「只增不删」的表比想象中多:操作日志、审计流水、消息队列的落库、工单提交、报名记录,都是这个形状。

快照那一列,四次全部「是」,恢复耗时 2 到 4.6 毫秒,快照 12 KB。 十二 KB,一张缩略图的大小。恢复比写进去还快。

dry-run 那一列,四次全部「否」,而且更慢。 这一点最反直觉:字段校验花了 20 到 25 毫秒,比直接写还贵,却一点保护作用都没有——因为校验通过之后,写照样发生了。

dry-run 防的是「格式错」,防不了「不该写」。这两件事经常被混为一谈。


五、dry-run 为什么救不了这件事

上面那张表里,dry-run 那三行是全篇最值得记住的。

很多人对「安全写入」的想象是这样的:先预演一次,确认没问题,再真正执行。这个模型对「部署」「迁移」这类可预演的动作成立,对「往一个只增表里写一条」不成立。

因为预演和执行之间没有隔离。预演通过,意味着「这个请求格式合法、必填字段齐全、类型正确」——它证明的是请求能成功,恰好是这次事故里我们最不想证明的东西。

保护手段

防的是什么

防不了什么

本次是否有效

字段校验 / dry-run

格式错误、字段缺失

不该写、写错地方

无效

请求前人工确认

明显越界的动作

被表述成「验证」的动作

取决于提示词

写前快照

写坏之后恢复不了

写进去这件事本身

有效(唯一有效)

只读代理

任何写操作

任务本身需要写

有效,但要提前设

快照之所以有效,是因为它把「不可逆」变成了「可逆」,而不是试图阻止写入。这个区别很重要:护栏的目标不是让 AI 什么都做不了,是让它做的每一件事都能退回去。

我在本地把这条结论又验了一遍:恢复之后,表里的记录数回到 5 条,自增 ID 也没有被回退——严格说这不是「完全无损」,因为 ID 序列已经消耗掉了。对展示型数据来说无所谓,对流水号有意义的系统,快照只能恢复到「数据一致」,恢复不了「序列一致」。这一点要说清楚,别让人以为快照是万能的。

六、工具描述决定模型看见什么

复盘到第三天,我去看了一件之前没注意的东西:我给 agent 的工具定义。

tools = [{
    "name": "save_info",
    "description": "保存一条信息到系统",
    "parameters": {"title": "string", "content": "string"}
}]

问题就在 description 这一行。

在模型的视角里,世界是由工具描述构成的。它看不到数据库表结构,看不到这个接口只有 INSERT 没有 DELETE,看不到数据会不会出现在首页。它看到的是「保存一条信息」——这四个字在语义上无限接近「存个草稿」,而存草稿是人类世界里风险最低的动作之一。

我给它的说明书,把它引到了一个错误的先验上。

字段

我当时的写法

模型据此推断

应该怎么写

description

保存一条信息到系统

低风险、可撤回

向生产库追加记录,无删除接口

环境

未标注

不知道是生产

参数里带 env,值域限定 test

可逆性

未标注

默认可逆

明确写 reversible=false

影响面

未标注

不知道会展示

说明写入后前台可见

重新设计之后,工具描述长这样:

tools = [{
    "name": "save_info",
    "description": ("向业务库追加一条记录。该表只增不删,写入后无法撤回,"
                    "且会出现在前台展示位。仅在 test 环境允许调用,"
                    "prod 环境需人工签核。"),
    "parameters": {
        "env": {"enum": ["test", "prod"], "required": True},
        "title": "string",
        "content": "string"}
}]

我没有拿这套描述去做 A/B 实验,所以不宣称「改了描述模型就不会写」。但有一件事是确定的:模型的决策质量,上限由工具描述决定。 你没写在说明书里的事实,它只能靠猜,而它猜的方式和你不一样。

这也解释了为什么同一个模型,在别人的 agent 里表现得很稳,在你这儿就乱来。差别常常不在模型,在工具契约写得够不够狠。

工具契约要素

有

没有时的后果

环境标识

env 必填,值域受限

模型分不清测试与生产

可逆性

reversible 布尔

把不可逆当可逆

影响面

是否对外可见

把内部数据写成对外事故

调用条件

必须签核的场景

一路绿灯

失败语义

部分成功怎么算

重试放大影响

表里最后一行值得多说一句。「部分成功怎么算」这件事,在这次事故里也有影子:批量写 50 条的时候,如果第 30 条失败,agent 会不会重试?重试会不会重复写入?这些在工具契约里没有定义,模型只能自己决定。

我给自己的规则是:凡是不可逆的工具,必须在描述里写清「失败不要重试」。 这行字比任何提示词工程都管用,因为它把「重试」这个默认行为在契约层就掐掉了。

七、工具层护栏能挡多少

事后我做了第二组实验:给 AI 的动作空间加策略,看能挡住多少。

准备 20 个动作,9 个该拦(越权目标、生产写入、不可回滚的写),11 个该放(授权内的只读、测试环境的小写入)。四档策略逐级加条件。

策略

条件

放行

拦下

拦住该拦的

误拦

L0

不设限

20

0

0/9

0

L1

只允许 GET

10

10

7/9

3

L2

目标白名单 + 方法白名单 + 非生产

13

7

7/9

0

L3

L2 + 不可逆动作需签核

12

8

8/9

0

四行数字讲了四件事。

L0 什么都不拦。 这就是事故当天的状态:工具是裸的 HTTP 客户端,AI 想发什么就发什么。

L1 只允许 GET,拦下 7 个,误拦 3 个。 误拦的三条是「测试环境新建草稿」「测试环境删除草稿」「测试环境修改配置」——都是合法动作。一刀切的方法白名单会把活也切掉,这是它最常见的缺陷。

L2 加了目标与环境,误拦归零,但拦截数没涨。 它挡住了「未授权域名」和「生产写入」,却放过了「测试环境里批量新增 500 条」这种动作——因为从方法和环境上看,它完全合规,问题出在「这批数据删不掉」。

L3 加了「不可逆需签核」,拦截数到 8/9,误拦仍然为 0。

策略

漏掉的动作

漏的原因

L1

未授权域名 GET、导出全量数据

方法上都是 GET

L2

测试环境不可逆批量写、导出全量数据

前者合规、后者是读

L3

导出全量数据

只读,且目标在授权内

L3 那一格值得单独说:它不是策略写错了,是这类策略根本判不了。一个授权范围内的 GET,把全量用户数据拉走,从「方法 + 目标 + 环境」三个维度看,每一项都合格。它的问题在数据量和用途,这两件事不在 HTTP 语义里。

所以护栏能解决大约八成,剩下的两成必须靠人。

这句话不是安慰,是设计前提:如果你指望策略引擎做到 100%,它一定会在某个你没想过的维度上放行。


八、最严策略也漏的那一条

「导出全量用户数据」这个动作,我特意留在表里,因为它是所有方法级护栏的死角。

写操作有痕迹:一条记录、一个文件、一次提交。读操作没有。它不改变任何状态,所以「可逆性」这个维度对它无效;它用的又是 GET,所以「方法白名单」对它无效;目标还在授权清单里,所以「范围白名单」也无效。

能拦住它的只有三样东西:出站流量的大小、返回字段的敏感级别、以及人对自己行为的判断。

手段

能否发现导出

实现成本

方法白名单

否

低

范围白名单

否

低

响应体大小阈值

是(事后)

低

字段级敏感标记

是

中

出站流量监控

是

中

人工复核

是

高

这张表想说的是:不可逆动作的风险,不止「写坏」一种形态,「读走」同样不可逆。数据一旦离开边界,你没有任何快照能把它拉回来。

我在事故之后给自己加了一条土规则:任何一次请求,只要响应体超过 1 MB 或者包含身份证、手机号、订单号这类字段,就停下来先看一眼。 这条规则不优雅,但它拦得住东西。


九、授权书要写到什么颗粒度

这次事故暴露的第二件事,是授权书的颗粒度太粗。

先说我这边的前提:这次测试是签了授权协议的,英文合同,双方盖章,覆盖了目标范围、测试窗口和联系方式。所以从法律上讲,这次不属于「未授权测试」。但它依然出了事,说明一件事——授权解决的是「能不能碰」,解决不了「碰多深」。

我们的授权书写了什么、没写什么,拆开看很清楚:

授权书通常写了

授权书通常没写

后果

授权测试的目标范围

目标里的哪张表不能写

写进去也算「范围内」

测试时间窗口

单次请求的速率上限

批量写入不违规

允许的测试类型(渗透 / 漏洞验证)

验证手段的上限(能不能落数据)

落数据被当成验证

保密与数据处置义务

发现写入类缺陷时的具体动作

各人做法不一

责任限制条款

不可逆动作的书面确认流程

出事只能事后协商

左边一列是「许可」,右边一列是「边界」。绝大多数授权协议把许可写得很细,把边界留成空白。

所以正确的理解是:授权协议是入场券,不是免责书。它允许你进这栋楼,不表示你可以拆墙。

「对某系统进行安全测试」这句话,覆盖不了「能不能往生产表里写一条记录」。前者是范围,后者是方法,两者不是一回事。

我现在会把授权拆成七个维度,逐条确认:

维度

粗的写法

我现在要求写清

目标

某域名

域名 + 路径前缀 + 允许的参数集合

方法

安全测试

只读方法白名单;写操作逐条书面报备

环境

生产

生产只读;写入只在影子环境或测试租户

数据

未提

不写入、不删除、不导出超过 100 条

时间

长期有效

明确窗口,例如 3 天,每天 9:00 到 18:00

速率

未提

每秒不超过 5 个请求,并发不超过 2

处置

未提

发现写入类缺陷:只报告,不验证写入

最后一条是这次事故换来的教训,也是最反直觉的一条。发现「可以写」和「写进去」之间,隔着一个授权决定。 验证一个未授权写接口,用空 body 发一次、看返回码和报错结构,就够了;非要把数据落进去,那是在替客户做变更。

我把这条写进了自己的流程:任何写接口,验证上限是「一次空提交」,且必须在报告里注明「未实际写入业务数据」。如果客户要求证明数据能落库,那需要单独一封邮件确认,附上写入内容和回滚方案。

听起来很重,但比事后去求人删一条记录轻得多。


十、四道闸门

把上面这些收一收,实际的护栏有四层。任何一层单独用都不够,叠起来才成体系。

层

具体做法

能拦住什么

拦不住什么

合同层

授权书里写明「不可逆动作需书面确认」

越界动作的合法性

执行时没人看合同

流程层

不可逆动作走签核,默认拒绝

绝大多数误操作

被包装成「只读」的动作

工具层

HTTP 客户端封装:目标白名单 + 方法白名单 + 环境标记

手滑与模型乱发

授权内的越界数据读取

模型层

提示词写死「禁止写入/删除/上传」,要求发现即报告

一部分先验冲动

上下文漂移、被任务目标覆盖

四层里,成本最低、见效最快的是工具层。因为它是代码,不依赖人的记性和模型的理解。

我在本地把那套封装简化成了三十行,核心就三个判断:

def allow(action, policy):
    if action["host"] not in policy["hosts"]:        # 目标白名单
        return False, "目标不在授权清单"
    if action["method"] not in policy["methods"]:    # 方法白名单
        return False, "方法未授权"
    if not action["reversible"] and policy["require_signoff"]:
        return False, "不可逆动作需签核"
    return True, "通过"

三个判断带来的差别,就是上一节那张表里 0/9 到 8/9 的差别。

模型层那一栏要特别说明:提示词里的「禁止写入」有用,但不可靠。它会漂移——上下文一长、任务压力一大,模型会开始给「验证」找理由。所以模型层的约束只能当第一道提醒,不能当最后一道防线。

如果是团队,还需要三条制度

个人靠习惯,团队靠制度。三条最小可行的:

制度

做法

谁负责

成本

写操作报备

生产环境的写操作提前一天报备,附回滚方案

项目负责人

每次十分钟

工具默认拒绝

不可逆工具在 SDK 层默认禁用,需环境变量显式开启

平台

一次改动

事后抽查

每周抽 20 条 agent 请求,人工看有没有越界

安全负责人

每周半小时

第二条是三条里最容易被忽略、也最有效的。它把「默认允许」改成「默认拒绝」,把许可的动作从「没被禁止的」缩小到「显式开启的」。这个反转不需要模型配合,也不依赖人的自觉。

一位做红队的朋友跟我说过一句话,我记到现在:你写在提示词里的红线,是给模型看的;你写在代码里的红线,是给自己看的。 前者可能被忽略,后者不会。

十一、出事之后的六个小时

写这一节的时候我一直在想,如果当时处理得更快,结果会不会不一样。答案是:不会更快地删掉它,但会更快地止损。

按时间顺序,我当时做了六件事,事后看有五件是对的。

第一件,立刻停手。 不是停那个接口,是停整个 agent。它还在跑别的任务,如果继续,可能有第二处写入。停 agent 之后第一件事是把它的动作日志导出来,包括每一次请求的方法、路径、参数、返回码。

第二件,保全现场。 我没有删任何东西——也没法删。把返回体、写入前后的列表对比、时间戳全部存了下来。这一步后来很有用:跟资产方沟通时,能准确说出「写了一条、字段是什么、出现在哪个页面」。

第三件,评估影响面。 这一条最关键,也最容易做错。影响面不是「我写了什么」,是「谁会看到、会持续多久、能不能被清掉」。我当时的判断是:一条展示位记录,前台可见,无删除入口,需要开发介入。这个判断决定了后面要走多重的流程。

第四件,主动通知。 我给资产方发了邮件,说明时间、端点、写入内容、影响范围、我已经尝试过的处置方式。这一步拖不得,越晚说,性质越像隐瞒。

第五件,配合修复。 对方最后是从数据库层面清的。我提供了准确的表名线索和写入时间,他们按时间窗口定位到了那一条。这里有个细节:如果当时把日志删了,这条记录可能永远定位不到。

第六件,复盘。 也就是这篇文章。

跟资产方沟通的时候,有四件事必须一次说清,缺一件都会被追问:

要素

要写什么

不写的后果

时间

精确到秒的写入时刻

对方没法在日志里定位

端点

方法与路径

对方要去猜是哪个接口

内容

写进去的字段值

定位到了也不敢删

影响

前台哪里能看到

影响面评估失真

我这封邮件里最有用的是第三行——把写入的字段值原样贴了过去,对方按这个值在库里一查就找到了那一条。没有这个值,只能按时间范围扫,扫出来的候选可能有几十条。

动作

时间点

做对了没有

事后看应该怎么改

停 agent

02:40

对

应该更早,发现写入就该停

保全日志

02:45

对

应该自动存,不靠手动

评估影响

03:00

基本对

应该先查页面展示逻辑

通知资产方

03:10

对

应该带影响面和处置建议

配合定位

次日

对

应该提前记录自增 ID

复盘

三天后

对

应该当天写

有一件事我没做,现在觉得应该做:在写之前,先问一句「这条数据在哪能看到」。 这个问题花不了十秒,能省掉后面六个小时。

还有一个反直觉的教训:不要试图「再写一条把它盖掉」。 人在慌乱的时候会想各种办法让脏数据看起来不那么明显,比如写一条更显眼的记录、把标题改成「测试数据请忽略」。这些动作全都会让影响面变大,而且同样删不掉。


十二、责任这件事,AI 一分都分不走

这是本文标题的来源,也是我最想写清楚的一段。

事情发生后,我跟几个同行聊过。有人问:「AI 自己写的,算谁的责任?」这个问题在法律上其实没有讨论空间。

签授权书的是人,付测试费的是人,把 agent 跑起来的是人,给它真实域名和真实凭据的是人。AI 是工具,工具不承担法律责任,这是所有法域的共同前提。真到了要追究的那一步,坐在对面的只会是人。

环节

谁在做

出事之后谁承担

授权谈判

人

人(合同主体)

任务定义

人写提示词

人

工具权限

人配置

人

具体请求

AI 生成

人(执行者)

后果处置

人

人

表格最后一行是关键。AI 可以在几秒钟内发出上千个请求,但它的「速度」不会转化为「责任分担」。恰恰相反,速度越快,人越容易失去对动作的感知,而责任一点没少。

我在事后给自己定了一条更朴素的规则:凡是我不愿意亲手敲下去的请求,就不让 AI 敲。 这条规则不需要法律知识,只需要在写提示词的时候诚实一点——如果换成我自己坐在键盘前,我会不会发这个 POST?如果不会,那就别让 agent 发。

这条规则还有个副作用:它会逼着你把「验证」这件事想清楚。很多写操作之所以被发出去,不是因为它必要,是因为它简单。敲一个 POST 比设计一个不落库的验证方案容易得多。

团队层面还有三条,是我建议写进规范里的:

#

规则

为什么

1

生产环境默认只读,写操作必须走变更单

把「要不要写」从个人判断变成流程判断

2

不可逆工具在代码层默认拒绝,签核后才放行

不依赖模型自律,也不依赖人的记性

3

agent 的全部请求留存 90 天,可导出、可检索

出事时能定位,没出事时能抽查

第三条最容易被省掉,也最救命。我这次能准确告诉对方「写了一条、什么字段、几点几分」,靠的就是请求日志还在。如果日志只存在内存里、agent 退出就没了,那六个小时会变成六天。

这里要补一句,免得读者误解:有授权不等于可以随便写。 授权协议约束的是「测试行为」,不是「任何动作」。我们签了协议,所以这次不是非法入侵;但协议里没有一条写「可以往生产库写入不可删除的数据」,所以这次依然是操作事故,要向资产方交代、要配合清理。

两件事分开看:合法性由协议决定,妥当性由动作本身决定。前者是门槛,后者是专业度。

至于法律条文,我不在这里展开。只知道一条就够:未经授权对他人系统进行修改,无论修改者是人还是脚本,性质都一样。授权范围内的越界修改,同样要按合同和实际后果来谈。这些不是技术问题,技术手段再多也绕不过去。


十三、AI 红队的正确分工

说了这么多限制,不代表我反对用 AI 做红队。这次事故之后我还在用,只是分工变了。

环节

交给 AI

留给人

资产测绘

子域枚举、指纹识别、接口爬取

确认资产归属与授权范围

漏洞发现

参数 fuzz、响应差异比对、规则匹配

判断这是不是真漏洞

影响验证

只读回读、错误信息分析

决定要不要做写操作

报告撰写

结构化整理、复现步骤排版

定级、影响面描述、对外措辞

处置建议

检索同类案例

与资产方沟通、承诺修复窗口

核心区别就一条:AI 负责「发现」,人负责「决定」。 发现是幂等的,做一百次也不会改变世界;决定不是,做一次就可能留下一条删不掉的记录。

按这个分工,我现在跑一轮红队的流程是这样的:

  1. agent 在只读模式下跑完资产测绘和接口枚举,输出候选清单

  2. 我人工过一遍清单,标出「只读可验证」和「需要写才能验证」两类

  3. 只读类交给 agent 自动验证,写入类由我逐个决定,且默认只做空提交

  4. 所有请求经过同一个封装,带目标白名单和方法白名单

  5. 每天结束导出动作日志,人工扫一遍有没有越界

这套流程比「让 agent 自己跑」慢,慢大概三成。但那次事故告诉我,快的那三成不值一条删不掉的记录。


十四、红线的本质,是把不可逆变成可逆

写到这儿,可以把话收拢了。

大多数人理解的「红线」是一串禁止事项:不许删库、不许改配置、不许碰生产。这种理解有用,但不够,因为禁止事项永远列不全——你列了删除,它去新增;你列了新增,它去覆盖;你列了生产,它去测试环境批量写。

真正稳的红线长在另一个维度上:不问「能不能做」,问「做完能不能退回去」。

判断方式

提问

覆盖能力

维护成本

禁止清单

这件事允许吗

列不全,靠经验补

越用越长

可逆性分级

做完能撤回吗

与具体动作无关

一次定好,长期有效

我现在的分级是四档:

档位

例子

默认动作

只读

GET、查询、下载公开文件

放行,记日志

可回滚写

测试环境建草稿、有 delete 的接口

放行,写前快照

不可回滚写

append-only 保存接口、发消息、发邮件

必须人工签核

对外可见

首页展示位、公告、公开列表

必须人工签核,且写前确认展示逻辑

四档里,只有前两档可以交给 AI 自主执行。

后两档不是「谨慎执行」,是「默认不执行」——除非有人签字。

这条分级比任何一份禁止清单都好用,因为它不依赖你预见到具体的动作。

一个新接口、一种没见过的方法、一个奇怪的参数,只要你能判断「写进去能不能删」,它就能被归到某一档里。

回到那行字。

它现在还挂在那个页面上,等对方安排清理窗口。我每天会看一眼,不是自虐,是提醒自己:AI 可以在一秒钟内替我做完一件我事后要花六个小时处理的事。它能替我攻防,能替我写报告,能替我熬夜跑枚举。

它唯一替不了我的,是承担后果。

所以红线不能写给 AI 看,得写给自己看。写在代码里,写在授权书里,写在「这个 POST 我敢不敢自己敲」的那个瞬间里。


十五、给同样在用 AI 做红队的人

我后来把当时的提示词改成了这样,差别主要在「验证」的定义上。

改之前:

对目标做接口层授权测试,找出可未授权访问的接口,并给出可复现的验证证据。

改之后:

只做只读测试:GET、HEAD、OPTIONS。
发现写接口(POST/PUT/PATCH/DELETE)时,只做一次空 body 探测并记录返回码,
不写入任何业务数据,不重试,不批量。
生产环境一律视为不可写。任何写操作先输出计划,等人工确认。

改之后的那版有一个副作用:报告里「已验证」的条目变少了。以前能写「已验证可写入」,现在只能写「返回 200,未实际写入」。审核上确实弱一点,但这是我愿意付的代价——「未实际写入」这五个字,比一条删不掉的记录便宜太多。

最后列一份我现在的检查清单,都是这次事故之后加的,可以直接拿去用。

#

检查项

判断标准

1

授权范围是否包含写操作

没写就是没有

2

目标是否在生产环境

生产默认只读

3

要发的请求,我敢不敢自己敲

不敢就别让 AI 敲

4

写完能不能删

不能删就必须签核

5

数据会出现在哪

前台可见的按对外事故处理

6

有没有写前快照

没有就先做

7

动作日志能不能导出

不能就先加

8

出事之后通知谁

提前写好联系人

再补一条给同行的提醒,比这八条都重要:没有书面授权,不要碰别人的系统。 有授权,也要看清楚它覆盖到哪一步——覆盖了「扫端口」不代表覆盖了「写数据」,覆盖了「漏洞验证」不代表覆盖了「改配置」。AI 会把「验证」两个字执行到底,边界只能由你在授权阶段画清楚。

八条里最有用的是第三条。它不需要任何工具,也不需要任何流程审批,只需要在按下回车之前,把主语从「AI」换回「我」。

补一句关于这份清单怎么用。它不适合贴在墙上,适合贴在流程里:授权确认时过一遍前两条,配置工具时过第三条和第四条,出事时翻第八条。八条全是问句,没有一条是「应该怎么做」,因为每个人的系统不一样,能统一的是判断方式,不是动作细节。

最后回到标题。AI 能替你做的事越来越多:写代码、找接口、画图、写报告。它替不了的事只有一件——在事情出问题的时候,站在那儿承担。所以每次把任务交出去之前,最好先想清楚一件事:这件事如果搞砸了,能不能收场。

不能收场的,就自己动手,手动去测试。