第 14 讲 · 表单 POST 自动提交:CSRF、批量提交与幂等性
本讲目标 :从「读数据」跨到「写数据」------用 POST 把信息送进别人的系统。
讲清两只拦路虎:CSRF token (挡住伪造提交)和幂等性(超时后到底提交成功没有)。
配套代码 :
spiders/s14_form_submit.py运行 :
python spiders/s14_form_submit.py本讲产物 :
data/s14_submit_result.csv(4 条投稿的提交明细)
---下载地址:git clone https://gitee.com/wuyikui555/python-spider.git
一、从「读」到「写」:心理预期要换
前面 13 讲都在「读」。这一讲反过来:写。
典型场景长这样:
- 把整理好的名单批量录入内部系统
- 每天把报表数据自动提交到公司平台
- 爬到的价格变化推送到自己的监控系统
写操作比读操作危险十倍 ,因为它改数据,而且可能不可撤销 。
读错了,你只是拿到一份脏数据,删掉重来就是;
写错了,可能多出一条重复订单、一条错误工单、一封发给全体用户的邮件。
所以这一讲除了讲「怎么提交」,更要讲「怎么保证不提交错、不重复提交」。
好消息是:写操作在 HTTP 上没什么魔法。它就是一个 POST ,只不过表单里多了一个拦路虎------
csrf_token。
二、第一堵墙:不带 CSRF token 直接 POST → 403
CSRF(跨站请求伪造)这个名字听起来吓人,但它的目的很正当:
防止「别的网站偷偷替你的浏览器提交表单」。
服务器给你所在的会话 发一个随机串(CSRF token),表单必须把这个串一起带回来。
这样,一个冒充你的第三方网站就猜不到这个串,提交自然失败。
我们先不讲道理,先硬闯一次------登录之后,直接 POST 一个不带 token 的表单:
python
with HttpClient(base_url=site.base_url, timeout=8) as client:
login(client)
bad = client.post("/submit",
data={"title": "硬闯的投稿", "author": "匿名",
"category": "计算机"},
allow_redirects=False)
print(f" 不带 csrf_token → 状态码 {bad.status_code}")
实测输出(slogs/s14_form_submit.log):
不带 csrf_token → 状态码 403
服务器返回 → 403 CSRF 校验失败
403,一句话都不多说。
关键认知:403 是「帮你的」
很多新手看到 403 的第一反应是「这是反爬,我要绕过它」。方向错了。
403 挡住的是「伪造你身份的第三方网站」。
对我们来说,绕过它不需要「破解」------
只要老老实实按流程来:先 GET 表单页拿到 token,再带着 token POST 。
这是「照规矩办事」,不是「攻击」。
这一点非常关键:CSRF token 不是障碍,它是流程的一部分。
你按照真实浏览器填表的方式去做,token 自然就在页面上。你根本不需要「绕过」任何东西。
三、正确姿势:先 GET 拿 token,再带着 token POST
真实浏览器是怎么提交这个表单的?
- 你打开
/submit页面(一个 GET) - 页面 HTML 里有个隐藏字段 :
<input type="hidden" name="csrf_token" value="xxxx"> - 你点「提交」,浏览器把这个隐藏字段连同你填的内容一起 POST 回去
我们照做:
python
def extract_csrf(html: str) -> str:
"""从表单页面里把隐藏的 csrf_token 抠出来。
真实项目里 token 可能藏在:隐藏 input / meta 标签 / 某个 JS 变量里。
统一思路是「先用浏览器 F12 找到它,再写选择器定位」。
"""
soup = BeautifulSoup(html, "lxml")
node = soup.select_one('input[name="csrf_token"]')
return node.get("value", "") if node else ""
然后:
python
form_html = client.get("/submit").text
token = extract_csrf(form_html)
print(f" 从表单页提取 csrf_token → {token or '(空!可能是没登录)'}")
ok, msg = submit_one(client, PAYLOAD_ROWS[0], token)
print(f" 提交第 1 条 → {ok}|{msg}")
实测输出:
从表单页提取 csrf_token → 64ee47601d07bd29
提交第 1 条 → True|提交成功:深入理解计算机网络(当前共收到 1 条投稿)
成功了。 对比一下两次请求:
| 步骤 | 请求 | 关键点 |
|---|---|---|
| 1 | GET /submit |
从返回的 HTML 里抠出 csrf_token |
| 2 | POST /submit |
表单里带上 csrf_token + 业务字段 |
隐藏字段不是可有可无的装饰,它是表单的一部分,必须一起提交。
提交时漏了任何一个隐藏字段(
csrf_token、_method、form_id......),你拿到的都可能是一个「表单又回来了」的响应,而不是成功提示。
怎么判断「提交成功了」?
看 submit_one 的返回值:
python
def submit_one(client, row, token) -> tuple[bool, str]:
resp = client.post("/submit", data={"csrf_token": token, ...}, allow_redirects=False)
if resp.status_code != 200:
return False, f"HTTP {resp.status_code}"
soup = BeautifulSoup(resp.text, "lxml")
for p in soup.select("p"):
text = p.get_text(strip=True)
if text.startswith("提交成功"): # 找绿色提示行
return True, text
# 没找到成功提示 → 服务端把表单又渲染回来了(通常意味着校验没通过)
return False, "提交被退回(表单又回来了,通常意味着校验失败)"
注意最后那个 else 分支的判断逻辑:「表单被原样退回来」= 提交失败。
这是判断写操作成败的一个通用套路------因为很多时候服务器不会给你一个明确的「失败」状态码,
它只是把表单重新渲染给你,让你接着改。
四、批量提交与 token 刷新
单条提交会了,批量就简单了:一次登录,循环提交多条。
python
for i, row in enumerate(PAYLOAD_ROWS, 1):
# 每提交一次,服务端通常会换一个新 token(防止重放),
# 所以稳妥做法是每条都重新取一次。
token = extract_csrf(client.get("/submit").text)
ok, msg = submit_one(client, row, token)
results.append({...})
print(f" [{i}/{len(PAYLOAD_ROWS)}] {row['title']:<12} → {'成功' if ok else '失败'}")
time.sleep(0.05) # 写操作更要限速
实测输出:
[1/4] 深入理解计算机网络 → 成功
[2/4] 万历十五年 → 成功
[3/4] 牛奶可乐经济学 → 成功
[4/4] 人类简史 → 成功
服务端累计收到投稿:5 条
(说明数据真的写进去了,不只是我们自说自话)
注意「5 条」这个数字。 我们批量提交了 4 条,为什么是 5?
因为第 3 节单独提交过第 1 条 (深入理解计算机网络),加上批量这 4 条,正好 1 + 4 = 5。
这里要诚实说明一个差异 :脚本里的注释写的是「服务端通常会换一个新 token」,
但本靶场其实没有换------看服务端实现:
python
def _csrf(self) -> str:
sid = self._cookie("sid")
if not sid:
return ""
return CSRF_TOKENS.setdefault(sid, secrets.token_hex(8)) # ← setdefault
它用的是 setdefault:同一个会话,token 只生成一次,之后一直复用 。
所以本靶场里,每条重取也好、开局取一次也好,拿到的是同一个 token。
那为什么还要写成「每条重取」?
因为真实站点行为不一。 有的站 token 每会话固定,有的站每次请求都换新 (防重放)。
写代码时按「最严格的假设」来------每条都重新取一次 ------这样两种情况都能跑通,
而不换 token 的站只是多了一次无用的 GET 而已。稳健 > 省一次请求。
写操作要限速
那句 time.sleep(0.05) 别删。写请求比读请求更该限速 ------你每一条都在给人家的数据库
增加一行。读满了顶多被限流,写满了是真的在给人家上强度。
五、幂等性:同一批数据提交两遍,会怎样?
「幂等」这个词翻译成人话就是:同一个操作执行一次和执行多次,结果一样吗?
GET /book/1是幂等的:读 100 次,数据不会变POST /submit通常不是:提交两次,就多两条
我们真的把第一条又提交了一遍,然后看服务端的计数:
python
before = len(SUBMITTED)
token = extract_csrf(client.get("/submit").text)
submit_one(client, PAYLOAD_ROWS[0], token) # 把第一条再提交一次
after = len(SUBMITTED)
print(f" 重复提交 1 条 → 服务端条数 {before} → {after}")
实测输出:
重复提交 1 条 → 服务端条数 5 → 6
5 → 6,那条真的被又写了一遍。 这个靶场「照单全收」,所以重复提交就是实打实地多了一条。
但在真实系统里,重复提交是事故 :会多出一张重复订单、一条重复工单、
一份重复报表。而且它经常发生在你根本不知道的时候------比如网络超时你重试了一下。
三种保证幂等的常见做法
| 做法 | 思路 | 适合场景 |
|---|---|---|
| 业务主键去重 | 提交前先查一次「这条存在吗」,存在就跳过 | 有天然唯一键(订单号、学号) |
| 幂等键(idempotency key) | 每次提交带一个唯一串,服务端见过就直接返回上次结果 | 接口是你/合作方能改的 |
| 加唯一索引 | 让数据库帮你拦,冲突就当成「已存在」处理 | 有 DB 写入权限 |
幂等键是最优雅的一种,值得多说一句。它长这样:
python
import hashlib
key = hashlib.md5(f"{row['title']}|{row['author']}".encode()).hexdigest()
client.post("/submit", data={..., "idempotency_key": key})
服务端第一次见到这个 key 就正常处理并把结果存下来;再见一次就直接把上次的结果还给你 ,
不再执行。这样你的爬虫超时重试,也不会造成重复写入。
顺带一提,
utils/store.py里的fingerprint()就是干这个的------把若干字段拼成一个 MD5 指纹,用来做「内容级去重」。第 10 讲会用它配合 SQLite 的
ON CONFLICT ... DO UPDATE做真正的 upsert。
六、写操作的三条纪律
写脚本的第一原则,不是「怎么写」,是「怎么保证不写错」。三条纪律:
1. 先 dry-run。
用一个 --dry-run 开关,只打印「将要提交什么」,确认无误再真正提交。
python
if args.dry_run:
for row in PAYLOAD_ROWS:
print("[dry-run] 将提交:", row)
return 0
# 确认无误后,才走到真正的提交逻辑
这是所有「写脚本」的第一原则。先用眼睛过一遍,比事后回滚便宜一万倍。
2. 失败要能定位。
每条提交都记录 (id, 请求内容, 响应),出问题才知道是「哪条、为什么」失败。
本讲的 s14_submit_result.csv 就是干这个的:
提交明细已落盘:s14_submit_result.csv
落盘留痕,是写操作的「黑匣子」。真出事的时候,你会庆幸自己存了它。
3. 不要重试「不确定是否成功」的写请求。
| 请求类型 | 超时了怎么办 |
|---|---|
| 读(GET) | 随便重试,反正不改数据 |
| 写(POST) | 先查状态,再决定要不要重试 |
读请求超时随便重试;写请求超时,你根本不知道服务器到底执行了没有 ------
可能没收到(该重试),也可能收到了但响应丢了(重试就重复)。
所以正确的做法是:先查一次「这条在不在」,再决定。
否则就是「订单被下了两次」的经典事故。
合规提醒
这一讲教的「自动提交表单」,是一条双刃剑能力:
- 只在你自己的靶场,或获得明确授权的站点上练。
- 批量向第三方站点提交表单(尤其是垃圾信息、刷单、刷评论),
可能构成破坏计算机信息系统 或不正当竞争,不要碰。 - 靶场
robots.txt里写着Disallow: /submit------它存在就是为了提醒你:
「能做」和「可以做」是两回事。
把
base_url换成真实站点之前,至少确认三件事:① 这个写接口是你有权调用的吗?② 你重复提交会不会造成实际业务事故?
③ 对方有没有公开的 API 或明确的自动化许可?三者有一个「不确定」,就先停手。
本讲小结
| 能力 | 一句话要点 |
|---|---|
| 写操作认知 | 读是「要数据」,写是「改别人的数据」,心理预期和防护等级都要换 |
| CSRF | 不是障碍是流程:先 GET 拿 token,再带着 token POST ,缺了就 403 |
| 隐藏字段 | 表单里的隐藏字段(如 csrf_token)必须一起提交,漏一个就失败 |
| 判断成败 | 别只看状态码,看「有没有成功提示」「表单是不是被原样退回来」 |
| token 刷新 | 按「每条重取」的严格假设写,兼容「每会话固定」和「每次刷新」两种站 |
| 幂等性 | 重复提交 = 事故;用业务主键 / 幂等键 / 唯一索引保证只写一次 |
| 三条纪律 | 先 dry-run、失败留痕、不确定是否成功的写请求不要盲目重试 |
| 合规 | 只在自己的靶场或获授权的站点练写操作,批量提交第三方可能违法 |
下一讲
现在已经能登录、能提交了。但这两讲都建立在同一个假设上:
我们要的数据,藏在服务器返回的原始 HTML / 表单里。
下一讲,这个假设会彻底崩塌。
有一类页面,requests 抓回来的 HTML 里根本什么都没有 ------
你打开它,浏览器能看到数据;你用 requests 抓,只有一个空的 <ul> 和一句「加载中...」。
数据不是服务器给的,是浏览器里的 JavaScript 算出来、再挂上去的。
对付它,前面 14 讲所有手段全部失效 。得请出一个新角色:Selenium 。
它很强大,但也很慢、很重、很脆------下一讲会讲清「什么时候才真的该用它」。