LearnSpider 笔记

第 15 关：蜜罐与爬虫封禁 —— 数据是假的，陷阱是真的

Sat, 03 Oct 2026 10:03:10 GMT

本文是 LearnSpider 第 15 关的解密教程。这一关的靶场是最普通不过的一个 HTML 列表页：不加密、不验签、不弹验证码，5 页 × 10 条公告，谁都能抓。难的是你不知道自己抓到的是不是真的 —— 页面里埋了三类「只给爬虫准备」的东西：看不见的行会被当成数据，看不见的链接和字段碰一下就进小黑屋，之后拿到的每一份数据都对不上。这一关真正要带走的两条习惯是：抓表格前先做可见性过滤、拿到数据先做一致性校验。

靶场：/playground/trap（登录后打开）　参考解法：参考代码/s17.py

现象#

打开靶场，就是一个普通的公告列表：公告编号 / 项目名称 / 金额（万元）/ 更新于，页脚写着「本页 10 条 · 第 1 / 5 页」。
分页也普通：1 2 3 4 5 +「下一页」，下面还有个「跳转到第 N 页」的下拉框。
但 F12 一看就不对劲：DOM 里 table tbody tr 有 13 个，页脚却说 10 条。
用最常见的一把梭抓法（pandas.read_html）抓下来 → 每页 12 行（它只认内联 display:none，靠类名隐藏的两行照样抓）→ 5 页求和 → 提交上去判错。
更阴的是：如果你遍历了页面上所有 <a href>（或者把页面里所有 <input> 拼成请求参数），接下来同一页两次抓到的数字就不一样了，而且整页「更新于」全挤在同一秒。
全程没有任何报错：不 403、不弹验证码、不封 IP，HTTP 200，页面长得一模一样。

为什么「喂假数据」比「把门关上」更狠#

拦截方式	爬虫的感受	拦截方的成本
403 / 封 IP / 加验证码	立刻知道被拦了 —— 换 IP、换 UA、上打码、上代理池	要维护封禁名单与验证码服务，还会误伤真人
蜜罐 + 污染数据	根本不知道被拦了，拿着错数据继续跑几小时，最后算出来的结果一直是错的	只要多做一套假数据；真人访问完全无感

现实里的例子：招聘网站给爬虫返回”看起来正常、但根本不存在”的职位；电商给爬虫返回随机价格；行政区划接口给爬虫塞几个幽灵条目。目的都一样 —— 让你拿着脏数据走，而不是被你发现。

所以这一关的判错不会告诉你”你踩陷阱了”，只会说”答案不正确”。你得自己证明手里的数据是真的。

第一步：把「看不见的东西」找出来#

「看不见」在网页里不止一种写法，抓取时要一起判断：

写法	谁看不见	备注
内联 `style="display:none"`	所有人	不从渲染树里出现，`pandas.read_html` 也会跳过它
CSS 类 `display:none`	所有人	⚠️ `pandas.read_html` 照样吃（它只认内联样式，不解析样式表），按 `<tr>` 抓就更不用说了
CSS 类 `visibility:hidden`	所有人	⚠️ 占着位置、`read_html` 也照吃 —— 最容易漏的一种
离屏 `position:absolute; left:-9999px; width:1px; height:1px`	所有人	无障碍工具的经典写法，常被拿来当蜜罐
`opacity:0` / `height:0` / `overflow:hidden`	所有人	同上
`aria-hidden="true"` / `hidden` 属性	所有人 + 屏幕阅读器	语义层就已经声明”别读”
`<template>` / `<script type="text/template">`	所有人	模板数据，不是渲染结果

所以判断”能不能抓”的正确姿势是：先把页面里的 CSS 规则读明白，再逐行判断，而不是只认 display:none：

1
import re
2
from bs4 import BeautifulSoup
3

4
HIDDEN_HINTS = ("display:none", "visibility:hidden", "left:-9999px",
5
                "opacity:0", "height:0", "width:0")
6

7
def hidden_class_names(html: str) -> set[str]:
8
    """把 <style> 里认定「看不见」的类名挑出来。"""
9
    soup = BeautifulSoup(html, "html.parser")
10
    css = "\n".join(tag.get_text() for tag in soup.find_all("style"))
11
    names = set()
12
    for match in re.finditer(r"\.([A-Za-z0-9_-]+)\s*\{([^}]*)\}", css):
13
        body = re.sub(r"\s+", "", match.group(2)).lower()
14
        if any(hint in body for hint in HIDDEN_HINTS):
15
            names.add(match.group(1))
16
    return names
17

18
def is_hidden(tag, hidden_classes: set[str]) -> bool:
19
    """这个元素人眼看得见吗？（内联样式 / 类名 / aria-hidden / hidden 属性）"""
20
    inline = re.sub(r"\s+", "", (tag.get("style") or "")).lower()
21
    if any(hint in inline for hint in HIDDEN_HINTS):
22
        return True
23
    if set(tag.get("class") or []) & hidden_classes:
24
        return True
25
    if tag.get("aria-hidden") == "true" or tag.has_attr("hidden"):
26
        return True
27
    parent = tag.parent            # 隐藏也可能是包在看不见的父节点里
28
    while parent is not None and getattr(parent, "name", None):
29
        if parent.get("aria-hidden") == "true" or parent.has_attr("hidden"):
30
            return True
31
        parent = parent.parent
32
    return False

展开收起

这一关的三行幽灵数据，正好用了三种不同的隐藏方式：内联 display:none、CSS 类 display:none（.row-ghost）、CSS 类 visibility:hidden（.sp-invisible）。少了任何一种判断，都会多抓 3 行。

第二步：三类典型蜜罐（这一关全有）#

一、隐藏行（幽灵数据）#

页面表格里塞几行”人看不见、DOM 里在”的记录，编号和金额都做得和真数据同量级 —— 不会一眼假。踩中的人通常是：把整张表抓下来的人（//tr、table > tbody > tr、read_html）。这一关的三行幽灵行，read_html 会漏掉其中 1 行（内联 display:none 那个），另外两行照抓 —— 这就是”半吊子过滤”的代价：数字看着像对的，一算就偏。

破法：可见性过滤（第一步）+ 用页面自己给的条数校验。这一关的页脚明明白白写着「本页 10 条」，抓到 13 行（或者 12 行）就该停下来查。

二、隐藏链接（把爬虫往坑里带）#

页面里除了正常的分页链接，还有几个离屏的链接：一个 “下一页”、一个 “接口调试入口”、一个带 _hp=1 的 “备用线路”。它们用的是 .visually-hidden（无障碍样式的经典写法）和 .seo-aux（SEO 辅助块）这种看着完全无害的类名。

注意一个容易搞错的点：这些链接在自动化工具眼里是”可见”的 —— Playwright 的 is_visible() 只看有没有 1×1 的盒子，离屏元素照样返回 true。所以”人看不见”和”工具认为可见”是两件事，脚本得自己按几何位置判断：

1
box = link.bounding_box()          # 离屏元素：x = -9999
2
if box and box["x"] < 0:
3
    continue                       # 这种东西不是给人点的，别跟

破法：分页只跟随看得见、在文档流里的链接；把页面里所有 <a href> 都跟一遍是最容易被钓鱼的习惯。

三、隐藏表单字段（看着像统计参数）#

页面里有一个离屏的 GET 表单，字段是 utm_source / utm_medium / refer（名字取得很像埋点统计参数）。正常分页只需要一个 page 参数 —— 一旦你的请求 URL 里出现这几个字段，就等于举手说”我是把页面所有 <input> 拼起来发请求的脚本”。

破法：只带接口需要的参数；不要无脑收集页面上的所有输入（尤其 hidden 类型的）。

1
# 反面教材：把页面里所有 input 都拼成参数
2
params = {field.get("name"): field.get("value") for field in soup.find_all("input")}   # ← 会带上蜜罐字段
3
# 正面：只带你确认需要的
4
params = {"page": 3}

第三步：识别自己被「喂了假数据」#

被污染之后，服务端不会发任何通知，但留下的破绽有三处（这一关都埋了）：

信号	怎么用
同一页两次抓取不一致	最可靠的一招：抓两次比对金额；变了就说明数据是现造的
整页「更新于」挤在同一秒	假数据是同一批生成的，时间戳没有分散性；正常页面各行更新时间不同
页脚条数 ≠ 你抓到的行数	可能是幽灵行，也可能是数据被动过

把这三条写成脚本里的自检，比事后对着答案发呆强得多：

1
first = fetch(1)
2
if [row["amount"] for row in visible_rows(first)] != [row["amount"] for row in visible_rows(fetch(1))]:
3
    print("⚠️ 同一页两次金额不一样：踩到蜜罐了，现在停手等冷却")
4
    return          # 拿脏数据算下去只会得到错答案
5
if len(visible_rows(first)) != footer_count(first):
6
    print(f"⚠️ 抓到 {len(visible_rows(first))} 行，页脚说 {footer_count(first)} 条：先查隐藏行")

为什么必须”停手”：这一关的冷却会叠加（45 秒起步，每多踩一次 +30 秒，上限 180 秒）。越”多试几次找规律”，被封得越久 —— 真实站点的风控台账也是这么累积的。

第四步：被标记了怎么办#

本关的污染会自己到期（冷却结束、数据恢复原样）；真实站点不会，只能降低自己的可疑度或换出口。
换 IP / 清 Cookie 不一定有用：风控看的是”这个会话/账号做过什么”。本关按 user:<id> 记账，没登录才退化成按 IP。
真正该做的是回头看你请求了什么：是不是跟了隐藏链接、是不是把隐藏字段带上了。把行为改干净了，污染才不会再累积。

服务端那边只留一行日志，不会回给调用方（这就是真实站点的做法）：

1
CH-015 蜜罐命中 identity=user:1 kind=hidden-link:/playground/trap/next hits=1 接下来 45s 返回被污染的数据（不报错、不封禁）

第五步：完整脚本#

Terminal window

1
# 1) 浏览器登录靶场，F12 -> Application -> Cookies，抄下 session 的值
2
# 2) 填进 参考代码/s17.py 的 SESSION_COOKIE
3
python 参考代码/s17.py

脚本干了四件事：

抓第 1 页，先把页面里的蜜罐列出来（隐藏链接、隐藏表单字段）—— 知道坑在哪，才知道别碰；
做可见性过滤，把 13 行收敛到 10 行，并和页脚的「本页 N 条」对上；
同一页连抓两次做一致性校验，一旦发现被污染就当场停手；
5 页求和，提交。

反爬方视角：蜜罐怎么设计才有效#

诱饵要比正路”更好走”：隐藏的”下一页”看着比真分页还像分页，隐藏字段看着比真参数还像参数。
踩中不报错：一旦返回 403 或验证码，对方就知道被发现了；安静地喂假数据才有杀伤力。
假数据要”像”：同量级、同格式、有正常的分页。一眼假的（金额 999999）只会提醒对方。
留一条可自证的破绽（本关是同页两次不一致 + 时间戳同秒）：这是教学靶场的善意；真实站点往往把假数据做得每次一致，那就只能靠”用另一个数据源交叉验证”了。
记台账、能累积：踩过几次、踩了什么，都记下来，越踩越严 —— 这就是本关冷却叠加的由来。

排查清单（⚠️ 先看前三条）#

抓到的行数 ≠ 页脚条数 → 先做可见性过滤（display:none、visibility:hidden、离屏、aria-hidden），别急着怀疑算法。
同一页两次数据不一样 → 你被污染了：停手、等冷却（别多试），并且别再碰隐藏链接/字段。
整页「更新于」只剩一种取值 → 假数据的味道，同上处理。
pandas.read_html 只认内联 display:none：靠类名隐藏的行它照吃不误（本站 3 行幽灵行里它会漏掉 1 行、吃掉 2 行）—— 正确做法是”按 CSS 规则判断可见性”，不是只查一个属性。
别把页面里所有 <input> 拼成 params（尤其 utm_* / refer / _hp 这种”统计参数”）。
别遍历所有 <a href>；分页只跟随看得见、在文档流里的链接。
数据入库前先做校验：条数、唯一编号去重、同页两次一致、与另一个来源交叉比对。
请求头（Referer / UA）也保持像正常浏览 —— 这一关不看，真实站点会看。
答案不对时，先怀疑数据来源，再怀疑算法。这一关就是专门治”算法没问题但结果是错的”。
被污染之后重新抓一遍，看看数字有没有变：变了说明还在冷却里。

FAQ#

Q：这关有加密吗？ 没有。这一关就是要说明：反爬不一定是加密。校验可见性、校验一致性，是抓数里最容易被忽略、又最便宜有效的两道防线。

Q：为什么隐藏行的金额不写成离谱的大数？ 因为那样只会提醒你”这行是假的”。真实蜜罐的原则是”像”—— 同量级、同格式，让它在汇总里悄悄偏掉，你只会觉得”怎么算都不对”。

Q：Playwright 的 is_visible() 说隐藏链接是可见的？ 对，它只看有没有 1×1 的盒子。判断”人能不能看见”要看位置和尺寸：box["x"] < 0、宽高 ≤ 1px 的，都不该去点。

Q：能绕过污染吗？ 等冷却到期就行（背几个 45 秒）。但真正要练的是”别踩”：只抓该抓的、只带该带的参数 —— 真实站点的污染不会自己到期。

Q：页脚的「本页 10 条」是不是太便宜我了？ 它是这一关的”校验基准”。真实页面上到处都有这种基准（条数、合计、校验位、编号规律），只是大多数人抓完就走，从来不看。

第 14 关：Cookie 签名 —— 七层复合加密，和「密钥写在前端」这件事

Sat, 03 Oct 2026 09:29:33 GMT

本文是 LearnSpider 第 14 关的解密教程。这一关的数据分 5 页、每页 10 个数字，但接口只认一个签过名的 sign Cookie：这个 Cookie 是前端一段混淆过的 JS连着过七层算法算出来的（拼盐 → MD5 派生密钥 → 链式 XOR 流加密 → 16 字节矩阵转置 → S-box 替换 → 位置混淆 → 自定义字母表 base64）。页面只帮你签前 4 页，第 5 页得自己签。真正要记住的不是那七层，而是结尾那句：七层看着吓人，但没有一层是秘密 —— 盐、S-box、字母表全在 JS 里，读了就能给任意页码签名。这正是「把密钥交给客户端」这种做法的天花板。

靶场：/sign?challenge=CH-014（登录后打开）　参考解法：参考代码/s16.py　签名源码（混淆前）：参考代码/ch014-sign.src.js

本关的层次结构对着 参考代码/s14.js 搭 —— 那是从某真实站点扒出来的一段签名脚本，也是「拼盐 → 哈希 → MD5 派生密钥做流加密 → 矩阵转置 → 再哈希 → 矩阵乘 → 十六进制」这么一长串。真实站点管这叫「JS 加密」「七层签名」，本质一样。

现象#

打开靶场，页面上是一张 10 行的数字表 + 一排页码按钮 1 2 3 4 5：前 4 个正常，第 5 个按钮上挂着一把小锁。
点 1~4 任意一页，表里的数字马上换掉 —— 页面自己签好 Cookie 再请求，你什么都不用管。
点第 5 页，页面只会给你一句话：

1
第 5 页不在页面里 —— 得自己把签名算出来（算法就在 /static/sign/sign.js 里）

F12 → Network，整关只有两条接口（都是在登录之后发的）：

1
GET /api/challenges/CH-014/init          -> {"cookie_name":"sign","total_pages":5,"visible_pages":4,"page_size":10}
2
GET /api/challenges/CH-014/data?page=1   -> 200 {"code":"0","data":[362,783,...]}   ← 必须带 sign Cookie
3
GET /api/challenges/CH-014/data?page=5   -> 403（页面没给它签）

Application → Cookies 里能看到那个 Cookie：

1
sign = 2v6ewxxz9cPu3Sp24OI_4K…

一眼就看得出不是标准 base64：里面出现 - _，也没有末尾的 =。

三个「不能作弊」的细节，F12 里试两下就知道：

做法	结果
不带 `sign` Cookie 请求 `?page=1`	`403` `{"reason":"missing"}`
拿第 1 页的 Cookie 去要 `?page=5`	`403` `{"reason":"page"}` —— 页码被签进 Cookie 了
拿 6 分钟前的 Cookie 去请求	`403` `{"reason":"expired"}` —— 时间戳也被签进去了

页面上的 reason 字段只是给排查用的粗分类，真实提示只有一句「签名无效或已过期」。服务端不会告诉你差在哪，cookie=... 的原文只写服务端日志。

分层：这一关要拆七层#

层	做了什么	还原要点
L1	规范化拼串 `body = f"{page}.{timestamp_ms}"`	签的其实就是「哪一页 + 什么时候」
L2	派生密钥 `KEY = md5("LS14.spot2026")`	盐写死在 JS 里 —— 这是全关最大的一处弱点
L3	链式 XOR 流加密 `c[i] = p[i] ^ ks[i%16] ^ c[i-1]`，`ks = md5(KEY)`	和 CBC 一个味道；⚠️ 补零必须在加密之前
L4	每 16 字节当成 4×4 矩阵转置	转置是自逆的，正反都用同一个函数
L5	256 字节固定 S-box 替换（AES SubBytes 那个味道）	表就是 JS 里那个 256 项的数组
L6	位置混淆：`(b + i*7 + 13) & 0xFF`，再按 `i%7+1` 循环左移	逐字节可逆，但顺序不能乱
L7	用打乱的 64 字符表做 base64（无 padding）	字母表也在 JS 里

七层里没有一层用到真正的秘密：L2 的盐、L5 的表、L7 的字母表，全都在前端那一份 JS 里明摆着 —— 只是被混淆器换了个长相。

第一步：先把 Cookie 的用法搞清楚#

别急着读算法，先确认签名绑了什么，这决定了你要重算什么：

1
init = session.get("/api/challenges/CH-014/init").json()
2
# {"cookie_name": "sign", "total_pages": 5, "visible_pages": 4, "page_size": 10}
3

4
session.cookies.set("sign", "")                       # 不给签名
5
session.get("/api/challenges/CH-014/data?page=1")     # -> 403 missing
6

7
session.cookies.set("sign", cookie_of_page_1)         # 拿第 1 页的
8
session.get("/api/challenges/CH-014/data?page=5")     # -> 403 page

三个结论：

签名是按页签的（页码进签名），所以第 5 页不能复用第 4 页的 Cookie；
签名是按时签的（时间戳进签名，窗口 5 分钟），所以抄一个 Cookie 存起来慢慢用会过期；
签名只认 Cookie，不认 query / header，名字由 /init 下发（sign）。

到这一步你已经能画出要重算的东西：给定页码 page，算出 sign 的合法值 = 过一遍七层。时间戳用当前毫秒就行。

第二步：把混淆脚本扒开（只有两招障眼法）#

/static/sign/sign.js 是 JavaScript Obfuscator 的产物：控制流平坦化、十六进制变量名、死代码、字符串数组……别硬读。这个混淆器在这里其实只用了两招真正影响「能不能抄表」的手法：

招式一：数字被写成了算术表达式#

产物里 S-box 不是 [195,71,12,...]，而是：

1
[0x2*0x508+0x2117+-0x2a64, 0x1a42+-0x2178+0x27f*0x3, -0x10c1+-0xc43+0xf0*0x1f, ...]

求个值就是原数（0x2*0x508+0x2117+-0x2a64 = 195）。256 项的那个数组就是 L5 的 S-box。

招式二：字符串数组用的不是标准 base64 字母表#

字符串被塞进一个大数组、各自 base64 了一遍，但它所使用的字母表把大小写两半调换了：

1
var _0x5d73a6 = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';
2
//   标准 base64 是 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='

所以直接 base64.b64decode 会解出一堆乱码（这一点和 CH-012 的字符串表不一样，那个是别的变体）。把字母表换回去再解，长度 86 的那一条就是 L7 的 64 字符自定义字母表。

两招合起来，抠表的代码只有十几行：

1
import base64, re
2

3
JS_B64 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/="
4
STD_B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
5

6
def grab_tables(sign_source: str):
7
    # ① S-box：混淆器把数字写成算术表达式，求值即可（只放行十六进制字面量和 +-*）
8
    sbox = []
9
    for block in re.findall(r"\[[^\[\]]{300,}\]", sign_source):
10
        parts = block[1:-1].split(",")
11
        if len(parts) == 256 and all(re.fullmatch(r"[-+0-9a-fx*]+", part) for part in parts):
12
            sbox = [eval(part) & 0xFF for part in parts]
13
            break
14

15
    # ② 字母表：字符串数组项是「换过字母表的 base64」
16
    alphabet = ""
17
    for token in re.findall(r"'([A-Za-z0-9+/=]{40,})'", sign_source):
18
        fixed = token.translate(str.maketrans(JS_B64, STD_B64))
19
        decoded = base64.b64decode(fixed + "=" * (-len(fixed) % 4)).decode("ascii", "replace")
20
        if len(decoded) == 64 and len(set(decoded)) == 64:
21
            alphabet = decoded
22
            break
23
    return alphabet, sbox

展开收起

还有一条更省事的路：页面上的 window.LSSign 就是签名器本体，控制台里 LSSign.applyCookie(5) 一句话就能签第 5 页。能调用就等于能签 —— 这也正是本关要让你体会的那件事。但手写一遍七层，你才知道「混淆」到底挡住了什么。

第三步：把七层用 Python 复刻一遍#

从 参考代码/s16.py 里摘出核心（完整版见文件）：

1
def sign(page, timestamp_ms, *, alphabet, sbox):
2
    body = f"{int(page)}.{int(timestamp_ms)}".encode()          # L1
3
    if len(body) % 16:                                          # ⚠️ 补零要在加密之前
4
        body += b"\x00" * (16 - len(body) % 16)
5

6
    key = hashlib.md5(b"LS14.spot2026").digest()                # L2
7
    stream = hashlib.md5(key).digest()                          # L3 的密钥流
8

9
    encrypted, previous = bytearray(), 0                        # L3 链式 XOR
10
    for index, byte in enumerate(body):
11
        value = byte ^ stream[index % 16] ^ previous
12
        encrypted.append(value)
13
        previous = value
14

15
    transposed = bytearray()                                    # L4 4×4 转置
16
    for start in range(0, len(encrypted), 16):
17
        block = encrypted[start:start + 16]
18
        for column in range(4):
19
            for row in range(4):
20
                transposed.append(block[row * 4 + column])
21

22
    substituted = bytes(sbox[byte] for byte in transposed)       # L5 S-box
23

24
    mixed = bytearray()                                         # L6 位置混淆
25
    for index, byte in enumerate(substituted):
26
        bits = index % 7 + 1
27
        value = (byte + index * 7 + 13) & 0xFF
28
        mixed.append(((value << bits) | (value >> (8 - bits))) & 0xFF)   # 循环左移 bits 位
29

30
    accumulator, bits, out = 0, 0, []                           # L7 自定义 base64（无 padding）
31
    for byte in mixed:
32
        accumulator = (accumulator << 8) | byte
33
        bits += 8
34
        while bits >= 6:
35
            bits -= 6
36
            out.append(alphabet[(accumulator >> bits) & 0x3F])
37
    if bits:
38
        out.append(alphabet[(accumulator << (6 - bits)) & 0x3F])
39
    return "".join(out)

展开收起

四个「一抄就错」的地方，全是我踩过的：

补零必须在加密之前。先加密再补零，那些零没被加密，服务端倒推回来就是垃圾 —— 表现为「怎么算都 403」，而且看不出原因。
L6 是位置相关的：正着来的顺序是「先加偏移、再循环左移」，所以逆着来要先循环右移、再减偏移。顺序反了同样只是「403 看不出原因」。
逆层顺序要严格反着：正向是 L4 转置 → L5 S-box，所以解的时候先逆 L5（用逆 S-box），再逆 L4。这两层写反是这一关最容易犯的错。
如果顺手用 JS 对照实验，注意 JS 的 >> 是带符号右移：写循环左移必须是 (v << c) | (v >>> (32 - c))；另外 x >>> 56 会把位移量按 32 取模变成 x >>> 24，处理 64 位长度时得拆成高低 32 位分别写。

第四步：怎么确认自己抄对了（不用猜）#

页面自己签的前 4 页就是现成的答案，拿它当测试向量：

F12 → Application → Cookies，把第 1 页那次请求的 sign 值抄下来；
时间戳没法从 Cookie 里看出来（它被加密了），但能猜：签名就是刚刚这一分钟里生成的，于是从「当前时间」往前一秒一秒试：

1
for offset in range(120):
2
    guess = int(time.time() * 1000) - offset * 1000
3
    if sign(1, guess, alphabet=alphabet, sbox=sbox) == sampled_cookie:
4
        print("对上了：七层还原正确，时间戳 =", guess)
5
        break

参考代码/s16.py 的自检段就是这么干的。对上了再往下走 —— 这一关只要你把七层还原对了，后面的活就只有拼请求了。

另外两个顺手的对照点：

解出来的明文必须是 b"1.1760000000000" 这种形状（页码.毫秒，尾部补零要去掉）；
长度必须对得上：页码.毫秒 是 15 个字符 → 补到 16 → 加密 16 字节 → base64 出来是 22 个字符（无 padding）。长度不对就是 L4/L7 抄错了。

第五步：五页取齐，求和#

1
total = 0
2
for page in range(1, 6):
3
    # 页面只会签 1~4 页，第 5 页得自己签 —— 差别只在这里
4
    cookie = sign(page, int(time.time() * 1000), alphabet=alphabet, sbox=sbox)
5
    session.cookies.set("sign", cookie, domain="spider.jsnote.top")
6
    payload = session.get(f"/api/challenges/CH-014/data?page={page}").json()
7
    total += sum(payload["data"])
8
print(total)   # 提交这个总和

跑法：

Terminal window

1
# 1) 浏览器登录靶场，F12 -> Application -> Cookies，抄下 session 的值
2
# 2) 填进 参考代码/s16.py 的 SESSION_COOKIE
3
python 参考代码/s16.py

脚本会先把两张表从 sign.js 里抠出来，再让你粘一个页面上的 sign 做自检，然后老老实实签 5 次、取 5 页、求和。

每个账号的 50 个数字是按账号派生的（同一个人稳定、人与人不同），所以别拿别人的总和去提交。

这一关真正要记住的：为什么「七层」不解决问题#

盐、S-box、字母表全在前端 = 读者即拥有者。混淆只是把「读代码」变成「费点劲读代码」，它挡的是懒得读代码的人，不是攻击者。你能还原一次，就能给任意页码、任意时间戳签名。
更极端的是本关那条捷径：LSSign.applyCookie(5) —— 能调用就等于能签。哪怕你把算法藏在 VM 里（见 CH-011 / CH-012），只要它必须在浏览器里跑出结果，调用方就一定能拿到结果。
正确的做法是密钥不出服务端：用 HMAC 对参数签名（服务端持密钥）、或服务端下发一次性 token、再叠上服务端风控和限速。本站 CH-005 就是这个套路（HMAC-MD5 签名 + 会话绑定），CH-010 是另一个变体（RSA 公钥在前端、私钥在服务端）—— 那两关的「客户端多算一层」是为了不泄密，而不是为了加密给别人看。

排查清单（⚠️ 先看前三条）#

403 且 reason 是 format / 怎么算都不对：九成是补零顺序、逆层顺序（先逆 L5 再逆 L4）、或者 L6 的移位/偏移反了。
403 且 reason 是 page：Cookie 里签的页码和 ?page= 不一致 —— 别复用别的页的签名。
403 且 reason 是 expired：时间戳是毫秒，而且服务端只认 5 分钟内；本地时间跑偏也会踩到。
长度不对（不是 22 / 44 …）：L4 的转置块大小别写成别的数，body 要补齐到 16 的倍数。
抠出来的 S-box 只有 255 项 / 有重复：正则抓歪了（别用 \d+，产物里是十六进制表达式）。
解出来的字母表里有 + / 但没有 64 个字符：忘了把混淆器那个大小写调换的字母表换回标准 base64。
自检一直对不上：先确认你抄的那个 sign 是不是同一页的、以及是不是刚刚才生成的（超过 5 分钟就没意义了）。
换了账号还是同一批数字：数字是按 user_id 派生的，换个账号当然就变了 —— 别把数字硬编码进脚本。
请求 401：session Cookie 没带上（域名 / path 设错了）。
想省事直接用 LSSign.applyCookie(5)：能过，但那就只是「调用」而不是「还原」；本关的分数想拿得踏实，还是把七层写出来。

FAQ#

Q：为什么非要有 L4 转置和 L6 移位这种”看不出用途”的层？ 真实站点也这么干：层数本身就是门槛。对写脚本的人来说，多一层就要多对一次答案；对防护方来说，成本几乎为零。理解了这一点，你就知道为什么看到「七层加密」不该先慌。

Q：verify 为什么不直接返回「第几层解错了」？ 服务端只回一句「签名无效或已过期」，原因写日志。真实站点也这样 —— 把失败原因告诉调用方，等于给自动化脚本送调试信息。

Q：我能不能只逆推出「第 5 页」而不实现正向签名？ 可以，但要先用正向实现自检一次：没有测试向量，你不知道自己逆出来的东西是不是对的。这一关最容易走的路是「正向复刻 + 拿 1~4 页的现成 Cookie 自检」。

Q：时间戳是干什么用的？ 它的作用是限时：抄来的 Cookie 只有 5 分钟寿命，逼你现场算签名。真实站点还会把时间戳和会话/随机数绑在一起（一次一密），思路一致 —— 让「重放」失效。

第 13 关：点选验证码 + 一次一密的轨迹报文 + 行为风控

Sat, 03 Oct 2026 09:09:01 GMT

本文是 LearnSpider 第 13 关的解密教程。这一关的靶场是一张点选验证码：把图上所有文字点掉。看着像「识图题」，真正的坎却在后面 —— 提交的不是「点了哪几个坐标」，而是一整段鼠标轨迹（时间、坐标、速度），用 AES+RSA 加密成 w；AES 的密钥一次一密、IV 由 challenge 派生，抓包重放没用。就算坐标全对，只要轨迹像机器（匀速直线、等间隔撒点、瞬移），也会被服务端的行为风控拦下。

靶场：/captcha?challenge=CH-013（登录后打开）　参考解法：参考代码/s15.py

现象#

打开靶场，页面上就是一个普通的登录表单：用户名、密码、一个「登录」按钮，下面用虚线框标出演示账号 demo / demo123（写死在页面上，账号密码也已经填好了，直接点「登录」就行）。
点「登录」—— 弹出一个验证码窗口，标题写着「请点击图中的 N 个文字（不分先后）」。
图上有 3~5 个手写体汉字，散在噪点背景上。每点掉一个，图上会出现一个带序号的红色小圆点；点满 N 下自动提交，窗口里的数字就是这一轮的行为轨迹。
Network 里一共四条请求（都是点了「登录」之后才发出去的）：

1
GET  /api/challenges/CH-013/init   -> {"gt":"3f9c...","challenge":"cd5c...","rounds":3,"demo":{...}}
2
POST /api/challenges/CH-013/get    -> {"bg":"/api/challenges/CH-013/image?challenge=...","width":320,"height":160,...}
3
GET  /api/challenges/CH-013/image?challenge=...      -> 图片本体（image/png）
4
POST /api/challenges/CH-013/verify -> 请求体只有 {"gt","challenge","w"}；成功回 {"validate":"...","rounds_left":2}
5
POST /api/challenges/CH-013/login  -> {"username","password","validate"}，验证通过后才回 {"passphrase":"LS13-XXXX-XXXX-XXXX"}

w 长这样（两段，用 @ 拼起来）：

1
w = "SBx2K9...（base64，RSA 加密的 AES 密钥）" + "@" + "9kQm...（base64，AES 加密的轨迹 JSON）"

每次都换一张图，也每次都换一个 challenge：/get 返回的 challenge 和 /init 那个不一样，而且用一次就废。
手动点得慢一点、准一点，能过；但如果用脚本「算出中心点 → 瞬间点掉」，坐标全对也会失败 —— 而且服务端只会回一句：

1
{"code":"1","result":"fail","message":"验证失败，请重新完成验证"}

弹窗同时换上一张新图。它不告诉你差在哪（真实站点就是这样，「差多少」不会下发给调用方）—— 详情只写服务端日志：

1
CH-013 验证不通过 user=1 reason=track_uniform_speed detail={"image_id":"00047","speed_stddev":0.0001,...}
2
CH-013 验证不通过 user=1 reason=automation detail={"ua":"...Electron...","chromeKeys":0,"notification":"denied",
3
                                                  "soft":["UA 是 Electron 等嵌入式浏览器","window.chrome 是空的", ...],"score":3}

如果你是用 Playwright / Puppeteer / Selenium 打开的页面，那连”点得准”这一步都到不了 —— 服务端会先看你上报的浏览器环境，判定是自动化就直接拒绝（reason=automation）。这一层就是接下来要拆的第四步。

分层：这一关要拆五层#

层	手法	破法
报文加密	`w = base64(RSA(AES 密钥)) + "@" + base64(AES-128-CBC(轨迹))`	找到公钥，自己按同样格式拼 `w`
一次一密	AES 密钥每次现造；IV = sha256(challenge) 的前 16 个字符；challenge 一次性	别想重放，每轮都按当前 challenge 重算
前端混淆	采集/加密的代码在 `static/captcha/security.js`，真正的逻辑是一段 base64 源码，`new Function` 运行时才编译	解两层 base64（注意混淆器把大小写翻转了）；或 hook `Function`
反调试	每 500ms 拼出 `debugger` 触发一次断点，量 `Date.now()` 差值；一旦发现被停住就把采到的轨迹清空	`Ctrl+F8` 停用断点，或干脆不开 DevTools
行为风控	坐标 + 轨迹（速度/间隔/转弯/瞬移）	生成拟人轨迹（见第五步）
反自动化	静态指纹：`navigator.webdriver`、自动化全局变量、UA、`window.chrome`、Notification 权限……	洗指纹（`s15.py` 的 `clean_env()`），或者干脆不用浏览器

第一步：先把流程和 challenge 的用法搞清楚#

四步，和真实的点选验证码（极验那套）是一个套路：

1
init  = session.get(INIT_PATH).json()          # {"gt": ..., "challenge": ...}
2
got   = session.post(GET_PATH, json={"gt": init["gt"], "challenge": init["challenge"]}).json()
3
                                               # 换一张图 → 拿**新**的 challenge + bg + 图尺寸
4
image = session.get(BASE + got["bg"]).content  # 图片本体
5
verify= session.post(VERIFY_PATH, json={"gt": ..., "challenge": got["challenge"], "w": w}).json()
6
login = session.post(LOGIN_PATH, json={"username": ..., "password": ..., "validate": verify["validate"]}).json()

三个坑：

challenge 是一次性的：/init 给一个（用来换图），/get 再给一个（用来提交）。提交时必须用后一个，用错或者用两次都是 challenge 无效或已过期；
验证失败也作废：想再试一次，得重新 /init → /get 换张图，不能对着同一张图反复试坐标；
validate 也只能用一次：登录接口消费掉就没了。

第二步：认出图上的文字#

数据集只有标注框、没有字符内容（标注的类别就是 word / icon），服务端也不会告诉你答案。所以先得自己做检测：

1
import ddddocr
2
detector = ddddocr.DdddOcr(det=True, show_ad=False)
3
boxes = detector.detection(image_bytes)          # [[x1,y1,x2,y2], ...]

更稳的做法：这个靶场的图本来就来自一个目标检测数据集（仓库里那份 点选验证码目标检测数据集(1)/，VOC 标注，6300 张）。拿它训一个小模型（YOLO 之类），检测效果比通用 OCR 的检测头稳得多 —— 数据集里 labels/ 目录已经是 YOLO 格式了。

⚠️ 识别结果必须”不漏不重”：服务端要求「框全部点到、点击次数等于框的数量」。多认出一个噪点、或者少认一个字，都会直接判失败（错误码 click_count）。识别没把握时，换一张图比硬着头皮提交划算。

第三步：把 `w` 拼出来（一次一密在这儿）#

w 的结构和 CH-010 那套「RSA 传密钥 + AES 加密报文」像，但多了两处：

1
key_text = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(16))
2
# ① IV 不是固定值，而是 sha256(challenge) 的前 16 个字符 —— challenge 一换，密文全变
3
iv = hashlib.sha256(challenge.encode()).hexdigest()[:16].encode()
4
cipher = AES.new(key_text.encode(), AES.MODE_CBC, iv)
5
body = base64.b64encode(cipher.encrypt(pad(json.dumps(payload).encode(), 16))).decode()
6
# ② AES 密钥用 RSA 公钥包起来（PKCS#1 v1.5）
7
wrapped = base64.b64encode(PKCS1_v1_5.new(public_key).encrypt(key_text.encode())).decode()
8
w = f"{wrapped}@{body}"

明文的 payload：

1
{"gt": "...", "challenge": "...", "ts": 1760000000000, "size": [320, 160],
2
 "track":  [[dt, x, y], ...], "clicks": [[dt, x, y], ...],
3
 "env": {"webdriver": false, "ua": "...", "globals": [], "chromeKeys": 4, "notif": "default", ...},
4
 "ver": "1.0.2"}

track / clicks 都是增量时间编码：第一个元素的 dt 是「距 ts 多少毫秒」，后面每个是「距上一个点多少毫秒」。ts 是开始采集的时刻（图片刚画出来），size 是图片在页面上的显示尺寸 —— 服务端用它把像素坐标归一化，所以自己算的时候直接用图的原尺寸就行。env 是浏览器环境指纹（第四步要拆的那一层）。

公钥在哪儿？ 不在页面里明文写着，而是被 base64 藏进了混淆产物 security.js。参考代码/s15.py 里的 grab_public_key() 干的就是这件事：把产物里所有 base64 片段「原样 / 大小写翻转」各解两层，谁解出 BEGIN PUBLIC KEY 就是它：

1
for token in re.findall(r"['\"]([A-Za-z0-9+/=]{40,})['\"]", source):
2
    for candidate in (token, token.swapcase()):        # 混淆器把大小写翻转了
3
        outer = base64.b64decode(candidate + pad).decode()      # 第一层：payload（base64）
4
        inner = base64.b64decode(outer + pad).decode()          # 第二层：VM 源码
5
        # inner 里就有 PEM ——顺带还能看到整段采集/加密逻辑

顺带说一句：解出来的那份 VM 源码就是这一关前端的全部逻辑（怎么采轨迹、怎么派生 IV、反调试怎么判断），比动态调试省事得多。

第四步：先过”环境”这一关 —— 自动化浏览器一进门就被认出来了#

这一步很容易被忽略：很多人第一反应是用 Playwright / Puppeteer 打开页面点两下了事。结果会发现怎么点都过不去 —— 因为服务端除了看轨迹，还会把你上报的浏览器环境过一遍。

关于这一层，一个实测出来的事实值得先说清楚：在事件层面是查不出自动化的。

你可能以为的破绽	实测结果
注入的事件 `isTrusted === false`	❌ CDP 派发的事件到页面时 `isTrusted` 就是 `true`
`event.movementX/movementY` 恒为 0	❌ 照常按坐标差算出来（实测 18px 的步长 → `movementX = 18`）
只有 `mousemove`、没有 `pointermove`	❌ `pointermove / pointerdown / mousedown / mouseup` 一个不少
`screenX` 和 `clientX` 对不上	❌ 差值恒定（窗口偏移），和真鼠标一样

所以这一层是靠静态指纹判的（backend/click_captcha_risk.py 的 check_environment()）。最典型的那种写法 ——

1
browser = p.chromium.launch(headless=False)   # 甚至不用无头

—— 实测下来是这样：

信号	`headless=True`	`headless=False`
`navigator.webdriver`	True	True ← 一条就够
UA	`HeadlessChrome/149`	正常 Chrome（不带 headless 字样）
`navigator.plugins.length`	0	5
`Object.keys(window.chrome).length`	`window.chrome` 都没有	3（`loadTimes`/`csi`/`app`）
`Notification.permission`	denied	denied
`cdc_*` 之类的全局变量	无	无

也就是说：裸跑 Playwright，光 navigator.webdriver 这一条就露了，无头还是有头都一样。

硬信号（沾一个就拦）

navigator.webdriver === true —— Selenium / Puppeteer 的默认值，最经典的自动化标记；
window 上留着自动化框架的全局变量：cdc_*（ChromeDriver）、__selenium*、__driver_*、__playwright*、__puppeteer*、callPhantom、_phantom、__nightmare、domAutomation……
UA 里有 HeadlessChrome / PhantomJS / Selenium / Puppeteer / Playwright 字样。

软信号（攒够 2 分才拦 —— 单条会误伤真人）

UA 是 Electron 这类嵌入式浏览器；
Object.keys(window.chrome).length === 0（正规 Chrome 有一堆 chrome.* 对象）；
Notification.permission === 'denied'（headless Chrome 的默认值）；
navigator.plugins.length === 0；
window.outerWidth/outerHeight 为 0；
navigator.languages.length === 0。

脚本页面一加载就会把指纹 POST 给服务端（POST /api/challenges/CH-013/env）—— 也就是说门一开就被登记了，不用等你点验证码。服务端日志当场留一行，页面上也会弹一条提示：

1
CH-013 页面打开即识别 user=1 automation=True signals=["navigator.webdriver = true"] ua=...

怎么知道自己的浏览器报了什么？ 页面上的安全脚本内置了采集函数，控制台里直接看：

1
window.LSClick.collectEnv()
2
// {webdriver: false, ua: "...Chrome/150...", globals: [], chromeKeys: 4,
3
//  notif: "default", plugins: 5, languages: 2, outer: [2048, 1152], ...}

拿这个对照下面的「正规 Chrome 长什么样」：

1
navigator.webdriver                 // false
2
Object.keys(window.chrome)          // ["app","csi","loadTimes","runtime", ...]  ← 不是空数组
3
navigator.plugins.length            // 5
4
Notification.permission             // "default"
5
navigator.languages.length          // 2
6
window.outerWidth, outerHeight      // 都是正数

⚠️ 关键认知：这些字段全是客户端自报的，服务端没法验证真伪。所以这一层只能挡住「不洗指纹就上」的自动化；愿意花力气伪装的人照样能过 —— 这正是反爬的常态：每一层都不是铜墙铁壁，它的价值是把门槛抬高、把成本转嫁给对手。参考解法里的 clean_env() 干的就这件事。

顺带一提，本地开发要拿自动化浏览器测这一关（比如自己写 Playwright 脚本调试），可以在服务端开个后门：

Terminal window

1
LEARNSPIDER_CH013_ALLOW_AUTOMATION=1 python app.py     # 默认关，线上别开

第五步：最难的一关是”像个人”#

坐标对了只是入场券。服务端拿到解密后的轨迹，会同时看结果和过程：

检查	阈值	为什么
点击次数 = 文字框数量	相等	漏点 / 多点都算错
每一下都落在某个框里	归一化容差 3%（320×160 的图约 9.6×4.8 像素）	允许手抖，但不许点空
每个框恰好被点一次	—	防止把一个字点两遍充数
第一下点击的延迟	≥ 200ms	图片刚出来就点 → 人眼来不及看
相邻点击间隔	60ms ~ 8s	太快是连点器，太慢是挑战已过期
点击间隔标准差	≥ 2ms（间隔数 ≥ 3 时才判）	固定 `sleep` 的脚本标准差是 0.0x 毫秒
轨迹采样点数量	≥ 12	两点一线直接连过去的不行
瞬时速度	≤ 24 px/ms	人手做不到，这就是瞬移
速度标准差	≥ 0.02 px/ms	匀速直线插值的轨迹，这里是 0
方向变化次数	≥ 2（转角 > 10°）	整条轨迹一条直线没有转折

所以「算出中心点 → 直接点过去」必然挂在速度标准差上。要过这一关，得生成一段像人的轨迹：

顺带一提：采样点的「时间间隔标准差」这一条没有。浏览器按帧投递 mousemove，真人的事件间隔同样被量化到 ~16.7ms 且方差极小 —— 拿它当机器特征会大面积误伤真人。这是这关的一个设计取舍：宁可漏判，不可误伤；也提醒你，风控阈值不是越多越好。

1
def human_move(rng, start, end):
2
    """慢-快-慢（ease）+ 手抖。"""
3
    distance = math.hypot(end[0] - start[0], end[1] - start[1])
4
    steps = max(5, int(max(140.0, distance / rng.uniform(0.30, 1.10)) / rng.uniform(9, 17)))
5
    samples = []
6
    for step in range(1, steps + 1):
7
        ratio = step / steps
8
        ease = 3 * ratio ** 2 - 2 * ratio ** 3          # 速度先快后慢，绝不会是常数
9
        samples.append((
10
            max(4.0, rng.gauss(14, 4.5)),                # 事件间隔带抖动（±几毫秒）
11
            start[0] + (end[0] - start[0]) * ease + rng.gauss(0, 1.1),   # 手抖
12
            start[1] + (end[1] - start[1]) * ease + rng.gauss(0, 1.1),
13
        ))
14
    return samples

几个「别省」的细节：

别用线性插值 + 等分时间：那正是 speed_stddev ≈ 0 的来源，一条匀速直线就露馅；
ts 要贴近当前时间：服务端允许 3 分钟误差，超了直接判失败；
点之间要”停一下再按”（rng.uniform(90, 260) 毫秒），这也是人手特征；
别用 time.sleep(0.3) 这种固定节律：点得多了（≥4 下、3 个间隔）会被看间隔标准差。

第六步：完整脚本#

参考代码/s15.py 把上面五步串成了一条流水线：抠公钥 → init/get → ddddocr 检测 → 洗指纹 → 生成拟人轨迹 → 拼 w → verify → 登录拿口令。核心就四个函数：detect_targets()、clean_env()、build_payload()、build_w()。

跑通后拿到的是通关口令（形如 LS13-XXXX-XXXX-XXXX，按账号派生、唯一），把它提交到挑战广场。

排查清单（⚠️ 先看这一条）#

服务端只说一句「验证失败」，不会告诉你差在哪 —— 真实站点就是这样，把 reason / metrics 下发到页面等于给脚本送调试助攻。所以你只能自己对着上面的阈值表复现：

想知道到底挂在哪一条，就把 backend/click_captcha_risk.py 里的判定函数单独跑一遍（check_clicks() / check_timing() / check_track() 都是纯函数，喂进去就能出结论），或者看服务端日志 —— 每次失败都会留一行 CH-013 验证不通过 user=... reason=... detail={...}，里面的 image_id 能对上是哪张图。

常见的几种失败与原因：

可能的原因	怎么看出来
环境被判成自动化（最常见）	用 Playwright / Puppeteer / Selenium 直接跑必挂。控制台跑 `window.LSClick.collectEnv()`，对照上面的「正规 Chrome 长什么样」比一遍；服务端日志里有 `reason=automation` 和命中的信号
坐标没点准	容差只有图上 3%（320×160 的图约 9.6×4.8 像素）：检测框的中心算错了、忘了按显示尺寸缩放、或者点到了框外
漏点 / 多点	检测结果和真实框数量不一致（噪点被认成字、或者有字没认出来）→ 换一张图或换更稳的模型
首点太快	`ts` 设得太早（比如设成了脚本启动时间），或者一个循环里”算完就点”，没留看图的时间
轨迹像机器	匀速直线（速度标准差 ≈ 0）、点太少（< 12）、整条线没有转折、或者出现瞬移
间隔太整齐	用了固定 `sleep`；点得越多越容易露
`w` 根本没解开	IV 没用当次 challenge 派生；RSA 段不是 PKCS#1 v1.5；或者密文被动过
challenge 失效	用了 `/init` 那个旧 challenge；一张图验两次；验失败后没重新取图
轨迹点数为 0	多半是被反调试抓到了：挂断点会让采集结果被清空，`Ctrl+F8` 停用断点再来
`validate 令牌无效…已经用过了`	`validate` 一次性，换新的再登

FAQ#

Q：为什么图不从 CDN 直接下发，非要服务端代理一层？ A：题库种子（backend/data/click_captcha_seed.json）是随仓库走的，里面每条都带着 image_url 和标注框。要是把七牛的持久化链接直接发到浏览器，image_id 一露，查一眼种子就知道该点哪儿了。代理之后 URL 上只剩一次性的 challenge。

Q：反调试真的会拦我吗？ A：它只做一件事：发现「被断点停住过」就把采到的轨迹清空。不开 DevTools、或者开了但按 Ctrl+F8 停用断点，它完全无害。想读逻辑不必动态跟 —— 把 security.js 里的 base64 解两层，源码就出来了。

Q：识别的准确率不够怎么办？ A：两招。一是换一张图（服务端每次随机给图，识别没把握就重取）；二是拿仓库里那个数据集训一个检测模型 —— 数据就是为这一关准备的。

Q：为什么必须”像人”？ A：这就是行为式验证码的核心：它验证的不是「结果」而是「过程」。真实站点上，哪怕坐标分毫不差，一条匀速直线也会被判定为机器。反过来说，知道它看什么，也就知道该往哪儿使劲 —— 以及知道哪些站点的验证码不该硬闯。

Q：我用 Playwright 怎么点都过不去，为什么？ A：两个可能：环境被判成自动化（reason=automation），或者轨迹太”机械”。先看环境：控制台跑 window.LSClick.collectEnv() 看自己报了什么，再跟上面「正规 Chrome 长什么样」对一遍。要过的话有两条路 —— 洗指纹（像 s15.py 的 clean_env() 那样，用真实浏览器的值伪造一份），或者不走浏览器（自己拼 w，那样连环境字段都是你自己说了算）。

Q：这些环境字段服务端能验证真伪吗？ A：不能。它们全是客户端自报的，服务端只做「像不像正常浏览器」的启发式判断。所以这一层挡的是「不洗指纹就上」的自动化，挡不住愿意花力气伪装的人 —— 这不是缺陷，是这类防护的本来面目：每一层都把成本往上抬一点，最后决定胜负的是对手愿不愿意付出那份成本。

Q：我本地想用自动化浏览器测这一关怎么办？ A：服务端留了开关（默认关，线上不要开）：LEARNSPIDER_CH013_ALLOW_AUTOMATION=1 python app.py，打开后跳过环境检查，行为风控照旧。

第 12 关：接口下发 JS + 字符串混淆 + 内置 MD5 + 反调试

Fri, 02 Oct 2026 14:21:39 GMT

本文是 LearnSpider 第 12 关的解密教程。这一关换了个思路：页面本身几乎是空的，真正的防守逻辑不在静态文件里，而是登录后由接口现发一段 JS 下来。这段 JS 里：关键字全被十六进制转义映射（$dbsm_0x5d57）、一段字节数组解码后丢给 eval 执行、内置了一份完整 MD5 用来校验数据、再加一个 500ms 轮询的反调试 setInterval。

靶场：/shield?challenge=CH-012（登录后打开）　参考解法：参考代码/s14.py

现象#

打开靶场，页面上是 10 个四位数字和一个「本页合计」，能翻 5 页，最后一个是灰的。
打开 F12 —— 还没看清代码，Sources 面板就开始周期性断住：断点停在一行看着没什么的调用上，点继续，半秒后又断。这就是时间轮询式反调试。
Network 里只有三条请求：

1
GET /api/challenges/CH-012/init     -> {"script_url": "...", "data_url": "...", "total_pages": 5, ...}
2
GET /api/challenges/CH-012/script   -> 一段 JS（Content-Type: text/javascript）
3
GET /api/challenges/CH-012/data?page=1
4
      -> {"code":"0","qz":[...字节数字...],"sig":"b1cd5e3ce7fb9b18e4390f76c27ec005","page":1,...}

那段下发的 JS，静态搜 debugger、setInterval、eval、md5 全都搜不到：

1
var $dbsm_0x5d57 = function (_0x1a2b, _0x3c4d) {
2
  var _0x1a2b = [...'\\x64\\x65\\x62\\x75\\x67\\x67\\x65\\x72', ...];   // 都是转义，看不出是什么
3
  return _0x1a2b[_0x3c4d];
4
};

数据接口返回的 qz 是一串数字（字节值），不是明文；旁边还有 sig 做校验。
直接改 page=6 → {"code":"1","message":"页码超出范围（一共 5 页）"}。

分层：这次要拆的是”下发的代码”#

层	手法	破法
反调试	`setInterval` 每 500ms 用 `(0, eval)(表[2])` 触发一次 `debugger`，并用 `Date.now()` 前后差值判断是否被停住 → 停住过就 `for(;;){}` 死循环	`Ctrl+F8` 停用断点；或换无调试器的环境跑（脚本、Playwright）
字符串混淆	所有关键字/函数名走 `$dbsm_0x5d57(i)` 字符串表，表里是 `\xHH` 转义	在控制台 `[...Array(14)].forEach((_,i)=>console.log(i, $dbsm_0x5d57(i)))` 直接打印全表
代码隐藏	`var qz = [...]` 字节数组，XOR 后 `eval` 执行，真正逻辑（`LSShield`）到运行时才存在	解 XOR 就能拿到源码；或 hook `eval`/`Function`
数据加密	数字被转成 ASCII 再用同一套 XOR 编码成 `qz`，附 `sig = md5(明文 + 盐)`	找 XOR key 和盐，自己解
内置 MD5	整份 MD5 实现塞在脚本里，不依赖外部库	说明它只是自校验，不是”不可解密的加密”

第一步：先把反调试按住#

下发的脚本里（还原转义后）核心就这几行：

1
function _0x5d57_0x6() {
2
  var t0 = Date.now();
3
  (0, eval)($dbsm_0x5d57(2));                  // 表[2] = 'debugger'
4
  if (Date.now() - t0 > 200) { for (;;) {} }   // 被调试器停住过 → 死循环
5
}
6
w[$dbsm_0x5d57(1)](_0x5d57_0x6, 500);          // setInterval(fn, 500)

三个要点：

debugger 不是关键字写在源码里，而是从字符串表里取出来、再用间接 eval (0, eval)(...) 执行 —— 所以”在 debugger 那行打个断点”这招没用，静态也搜不到；
它用时间差检测调试器：真被断住时 Date.now() 会跳几百毫秒以上，于是主动进死循环；换句话说，没有调试器时它完全无害（这也就是为什么爬虫脚本可以在无头环境里正常跑）；
应对方式：DevTools 按 Ctrl+F8（Deactivate breakpoints），或在 setInterval 被调用前
```
1
window.setInterval = (fn, ms) => (console.log('拦下定时器', fn.toString()), 0)
```
更省事的当然是根本不跟调试器。

补充一个通用招数：Function / eval 都是”运行时才出现源码”的典型入口，给它们加一层 Proxy 就能把参数（也就是被隐藏的代码）打出来：
1
const rawEval = window.eval;
2
window.eval = (src) => (typeof src === 'string' && console.log('eval:', src), rawEval(src));

第二步：把字符串表翻译出来#

$dbsm_0x5d57 就是个数组下标查表，表项写成十六进制转义只是为了别让关键字出现在静态文本里。在控制台（脚本已加载后）敲一行就全出来了：

1
$dbsm_0x5d57(0)   // '\x6c\x73\x73\x68\x69\x65\x6c\x64' 系列...

或者干脆本地解码（s14.py 里的 decode_qz 一样的思路）：

1
>>> bytes.fromhex("6465627567676572").decode()   # 'debugger'
2
>>> bytes.fromhex("736574496e74657276616c").decode()  # 'setInterval'
3
>>> bytes.fromhex("6576616c").decode()          # 'eval'

翻译完，整段脚本的可读性就回来了：w.LSShield = { decode, split, digest, verify, ready }。

第三步：解 `qz`（真正的数据）#

数据接口给的 qz 是明文的每个字节异或一个固定值（这一关是 0x5a），拿到明文后还能顺手验一下摘要：

1
text = ''.join(chr(b ^ 0x5a) for b in payload["qz"])          # "9725,5484,..."
2
assert md5(text + "qz2026") == payload["sig"]                  # 和内置 MD5 做的是同一件事
3
values = [int(x) for x in text.split(",")]

XOR key 和盐在哪儿？ 就在下发的那段脚本里 —— 而且把它们解出来也能看到： qz 解码后是那支 LSShield 工厂函数的源码，里面明写着

1
return md5(text + 'qz2026').toString();   // 盐
2
bytes[i] ^ 0x5a                           // XOR key

所以 s14.py 的思路是：先解开 qz 拿到源码 → 从源码里正则抠出盐，一步都不用猜。

第四步：五页求和#

init 接口只说有几页（total_pages: 5）。循环翻页、每页解 10 个数字，累加即可：

1
for page in range(1, init["total_pages"] + 1):
2
    payload = session.get(init["data_url"], params={"page": page}).json()
3
    text = decode_qz(payload["qz"], 0x5a)
4
    assert md5(text + salt) == payload["sig"]
5
    total += sum(int(x) for x in text.split(","))

跑出来（参考代码/s14.py）：

1
XOR key = 0x5a，盐 = qz2026
2
第 1 页：10 个数字，本页合计 42584
3
...
4
第 5 页：10 个数字，本页合计 51223
5

6
五页数字总和：251142（提交这个数字）

排查清单#

一开 F12 就反复断住：反调试，Ctrl+F8 停用断点；或先 window.setInterval 打补丁再刷新。
控制台里 LSShield 是 undefined：脚本是页面动态插 <script> 加载的，等它加载完再取；也可以直接 fetch(init.script_url) 把源码拿下来自己看。
静态搜不到 debugger / setInterval：正常，它们分别由 (0, eval)(表[2]) 和 表[1] 生成。
qz 解出来是乱码：XOR key 不对（这一关是 0x5a，注意别用成了别的关卡的 key）。
sig 校验不过：盐不对，或者拼盐时多/少了分隔符（是 明文 + 盐，没有分隔符）。
code: "1"：页码超范围，一共 5 页。
/script 返回 401：接口需要登录态，脚本里要带 Cookie。

常见问题#

Q：为什么要把 JS 放到接口里发，而不是直接写进静态文件？ A：静态文件是”看得见、搜得到、能下载”的；放到接口里至少能按会话下发（每人不完全一样的参数）、能随时改，还想让你多花一步去”抓代码”。对爬虫来说多了一层”必须先登录、先分析”的门槛。

Q：内置 MD5 有什么用？不是随便就绕过了吗？ A：它的作用不是”加密”（MD5 本来也不可逆），而是自校验 + 提高门槛：让服务端能确认数据没被乱改，同时逼你读懂它的数据格式。

Q：既然是前端校验，改一下不就行了？ A：可以，但判断题在后端。前端能改的只是”你自己看到的”；数据、答案、判分都在服务端，所以正确姿势是还原算法，不是改前端。

最后提醒#

这些手段只适合在授权范围内的练习环境里研究。真实站点有服务条款和技术措施保护，绕过它们可能违法。

第 10 关：RSA 传密钥 + AES 加密报文（顺带一层 JavaScript 混淆）

Fri, 02 Oct 2026 14:16:46 GMT

本文是 LearnSpider 第 10 关的解密教程。这一关把「RSA + AES 混合加密」和「JavaScript 混淆」凑在一起：请求头 sm 是每次现算的，报文也不是明文，靶场还只放你书单里的前四页。

靶场：/books?challenge=CH-010（登录后打开）　参考解法：参考代码/s12.py

现象：请求头里有个看不懂的长串#

打开靶场，F12 → Network，只有一条 POST /api/challenges/CH-010/data：

1
sm: NBUhZ9tR...（很长的 base64）@P1q8oX...（另一段 base64）

没有请求体：参数全在 sm 里；
响应体不是 JSON：一串 base64 文本；
页面上的 5 个页码里最后 1 个是灰的，怎么点都不动；
把这条请求「Copy as cURL」重放一次 —— 大概率报 请求已过期。

辨型：两段字符 = RSA 传密钥、AES 传报文#

真实站点（spa16.scrape.center 那一类）就是这套组合拳，原因很实在：

算法	用途	为什么
RSA	只加密对称密钥	非对称加密慢、还有长度上限，塞不下整页数据
AES	加密报文本体	对称加密快，能加密任意长度
JS 混淆	让密钥/算法不好直接在源码里搜到	抬高静态分析成本

所以 sm 的两段是：

1
sm = base64( RSA_PKCS1_v1_5(AES 密钥明文) )  +  "@"  +  base64( AES-128-CBC(明文 JSON) )

定位资源：脚本里躺着的三件套#

<head> 里依次加载三个脚本：

1
/static/vendor/crypto-js.js        # AES（和第 11 关共用一份）
2
/static/vendor/jsencrypt.min.js    # RSA
3
/static/books/security.js                # 混淆过的业务逻辑：生成 sm + 解密响应

security.js 是 JavaScript Obfuscator 的产物：字符串全部收进数组、控制流被平坦化、还塞了死代码。别人怎么挖它的？两条路：

动态 hook（最快）——在控制台劫持几个函数，刷新页面，参数自己就打印出来了：

1
const raw = JSEncrypt.prototype.setPublicKey
2
JSEncrypt.prototype.setPublicKey = function (key) { console.log('PUBLIC KEY =\n' + key); return raw.call(this, key) }
3

4
const enc = CryptoJS.AES.encrypt
5
CryptoJS.AES.encrypt = function (plain, key, cfg) { console.log('明文:', plain, '密钥:', key.toString(CryptoJS.enc.Utf8)); return enc.apply(this, arguments) }

静态解混淆——用 de4js / synchrony 之类的工具还原字符串数组。注意：混淆器不只做了 base64，还把结果大小写翻转了一遍，所以直接 grep BEGIN 是搜不到的。把数组元素抓出来，swapcase() 之后再 base64 解码，才能看到 PEM：

1
for token in re.findall(r"['\"]([A-Za-z0-9+/=]{40,})['\"]", security_source):
2
    for candidate in (token, token.swapcase()):
3
        text = base64.b64decode(candidate + "=" * (-len(candidate) % 4)).decode("utf-8")
4
        if "BEGIN PUBLIC KEY" in text:
5
            print(text)   # ← RSA 公钥到手（公钥本来就是公开的）

还原公式#

1
key_text = 16 个 0-9a-f 的随机串                      # 每次请求现造一个
2
plain    = json.dumps({username, path, timestamp, pageNumber, pageSize})
3
aes_part = base64(AES_CBC_PKCS7(plain, key_text, iv="LS2026CH010IV000"))
4
rsa_part = base64(RSA_PKCS1_v1_5(key_text, public_key))
5
sm       = rsa_part + "@" + aes_part

服务端会逐项核对（顺序大致如下），这就是为什么”复用同一个 sm 重放”必然失败：

检查	不通过时的表现
能否解出 RSA 段 + AES 段	`400 报文格式不正确`（此时它还没法用你的密钥加密回复，只能明文说）
`username` 等于当前登录账号	`请求与登录账号不一致`
`path` 等于接口路径	`请求路径与签名不一致`
`abs(now - timestamp) <= 300 秒`	`请求已过期，请重新生成凭据`（注意时间戳是毫秒）
`pageNumber` 在 `1..5` 范围内	`页码超出范围（一共 5 页）`

页码只有序号：GET /api/challenges/CH-010/init（页面初始化时就会请求）只返回 username、page_count、visible_pages、page_size —— 不告诉你数据库里到底是哪五页。页面只放出前 visible_pages（=4）页，第 5 页只能自己写脚本取。

序号 n 对应哪一页数据由服务端按账号决定（每个账号一套，同人稳定、人人不同），所以在本地自己造一个 sm 去请求序号 1、2、3、4、5，就是你该拿的全部数据。

响应体同样是 AES：base64(AES_CBC_PKCS7(JSON, key_text, 同一个 IV))，用这次请求的 keyText 解。

完整脚本#

见 参考代码/s12.py（grab_public_key + build_sm + decrypt + 逐页汇总）。核心就三行：

1
sm, key_text = build_sm(public_key, username, page, page_size)      # 现造密钥并封装（page 是序号）
2
body = decrypt(key_text, session.post(DATA_PATH, headers={"sm": sm}).text)
3
total += sum(row["id"] for row in body["data"]["list"])             # 五页取齐后求和

跑出来大概长这样：

1
账号 xiajiao 的书单：共 5 页（页面只放出前 4 页），每页 18 条
2
第 1 页：18 条，本页 id 合计 123642696
3
...
4
五页书籍 id 总和：601884792（提交这个数字）

排查清单#

RSA.import_key 报 “RSA key format is not supported”：PEM 的换行丢了。从混淆产物里解出来的字符串里是 \n 转义，解码后要保留换行（s12.py 里直接 strip() 即可）。
解出来是乱码：IV 不对（必须是脚本里那个 16 字节常量）、密钥长度不对（16 字符 ≠ 16 位十六进制数，是按 UTF-8 取字节）、或者你用了 AES-ECB。
请求已过期：时间戳单位写成了秒，Date.now() 是毫秒。
页码超出范围：序号只有 1..5（/init 的 page_count），别把数据库页码当参数传。
400 报文格式不正确：sm 的分隔符不是 @、RSA 段没做 base64、或者公钥抄错了。
响应解不开：注意用的是本次请求的 keyText，不是第一次那个；每次请求都要重新生成。

常见问题#

Q：为什么不能只 RSA、或只 AES？ A：只 RSA 传不了长报文；只 AES 就得把密钥写在前端（等于公开）。混合加密是两者的折中：密钥每次随机、且只能被持有私钥的服务端读到。

Q：公钥是公开的，那这套加密还有意义吗？ A：有。它防的是「别人拿到你的报文改改就能用」——服务端核对 username/path/timestamp/页码，等于给请求绑上了会话与时效。

Q：为什么不干脆用浏览器自动化点五页？ A：可以，但那是把「每页都要重算密钥」的成本交给浏览器，而且不方便汇总求和。真实项目里更常见的是脚本直连。

最后提醒#

这套东西只在授权范围内的练习环境里练手。真实站点有服务条款和法律法规，未经允许的批量抓取可能违规甚至违法。

第 11 关：无限 debugger + VM 混淆 + 签名请求头

Fri, 02 Oct 2026 14:16:46 GMT

本文是 LearnSpider 第 11 关的解密教程。这一关的 JS 防守最”脏”：无限 debugger（关键字还是拼出来的）、base64 源码交给 new Function 在运行时编译、请求头 m 要现算签名，票价则靠 base64 + CSS 伪元素拼出来。

靶场：/mover?challenge=CH-011（登录后打开）　参考解法：参考代码/s13.py

现象#

打开靶场，页面数据正常。一按 F12，Sources 面板疯狂断住，断点停在一行看不出名堂的代码上，点继续还会再断 —— 这就是无限 debugger。
Network 里只有一条 GET /api/challenges/CH-011/flights?page=1，请求头有个 m：

1
m: 6cee2f75d7dab9a29548288f66fb3025_1790950486

看着像”32 位十六进制 + 下划线 + 秒”。

页面上的票价是 ¥ 后面几个空白的 <span>，源码里搜不到数字：

1
<span class="mv-digit d0a6fd0"></span><span class="mv-digit d2478eb"></span>

直接请求接口（不带 m）→ 403 {"code":"1","message":"请求凭据无效或已过期"}。
只有 5 个页码，最后一个是灰的。

分层：三层伪装，逐一剥#

层	手法	破法
反调试	无限 `debugger`；关键字用 `['de','bu','g','ger'].join('')` 拼出来，整段逻辑藏在 base64 里由 `new Function` 编译	先停掉断点（见下），或者干脆不跟 JS、直接 hook
请求签名	`m = md5(页码 + 毫秒时间戳 + 盐) + "_" + 秒`	找到盐，自己复现 md5
数据展示	票价是 base64，页面上再用随机类名 + CSS `::before{content}` 逐字画	解 base64 就行；想从 DOM 抄则要去读样式表

第一步：让无限 debugger 闭嘴#

它长这样（backend/static/mover/security.js 里的真实逻辑，混淆后更难认）：

1
var KEYWORD = ['de', 'bu', 'g', 'ger'].join('')   // 静态搜 "debugger" 搜不到
2
function spin() {
3
  new Function(KEYWORD)()                          // 每次现编译一次，断点打不住
4
  setTimeout(spin, 700)
5
}
6
spin()

随手可用的几个办法：

DevTools 里按 Ctrl+F8（或 Sources 面板右上角那个「禁止进入的斜杠图标」）Deactivate breakpoints —— 最省事；
在断住的那行右键 Never pause here；

控制台先打补丁再刷新：

1
window.Function = new Proxy(Function, { apply: (t, a) => { return t(...a) } })  // 甚至顺便 console.log 参数

或者根本别跟：这一关的签名不依赖浏览器运行环境，直接 hook + 写脚本更快。

⚠️ 别用 “Disable JavaScript”：页面自己也要靠 JS 取数。

第二步：把盐挖出来#

盐（XJ2026）在 base64 里那份「VM 源码」中。三条路，任选：

a) hook 摘要函数（最快） —— 页面加载了 crypto-js，全局有 CryptoJS：

1
const raw = CryptoJS.MD5
2
CryptoJS.MD5 = (s) => { console.log('md5 输入:', s); return raw(s) }

刷新页面，你会在控制台看到形如 11234567890123XJ2026 的明文：前缀是「页码 + 毫秒时间戳」，后缀就是盐。

b) hook Function，让它把源码吐出来：

1
const rawFunction = window.Function
2
window.Function = new Proxy(rawFunction, {
3
  apply(target, thisArg, args) { console.log('VM 源码：\n' + args[args.length - 1]); return target(...args) },
4
})

刷新后直接能看到那段 base64 解码后的源码（里面就有 SALT 和 buildM）。

c) 静态解 base64 —— 把产物里的长 base64 抠出来 atob。注意混淆器还给字符串做了大小写翻转（和 CH-010 抠公钥一样），所以更推荐 a/b 两条动态路线。

第三步：复现签名#

后端（和参考脚本）都在做同一件事：

1
m = md5(f"{page}{毫秒时间戳}{盐}") + "_" + 秒

几个容易踩的点：

毫秒参与摘要，但发出去的只有秒 → 服务端把那一秒内的 1000 个毫秒值各算一遍 md5 来比对（_ch011_verify_m()就是这么做的），所以别把毫秒直接拼进字符串发过去；
页码参与签名：用第 2 页的签名去请求第 1 页会被拒；
分隔符只能是 ASCII：HTTP 请求头是 Latin-1 的，塞个中文全角括号进去，浏览器会直接报 Failed to read the 'headers' property from 'RequestInit': String contains non ISO-8859-1 code point （真实站点之所以敢用中文括号，是因为它把签名放在 GET 参数里）。

第四步：票价（base64 + CSS）#

接口返回的每一行：

1
{"id": 101, "airline": "中国联合航空", "flight": "KN5911 波音737(中)",
2
 "depart": "13:50", "arrive": "17:30", "duration": "3小时40分",
3
 "value": "MTQ3Mg==",                 // base64("1472")
4
 "cls": ["d46c76e", "d0a6fd0", "de8a727", "d0041c8"]}

页面把 cls 逐字渲染成空 span，然后往 <head> 插一份 CSS：

1
[class~="d46c76e"]::before { content: "1" }
2
[class~="d0a6fd0"]::before { content: "4" }
3
...

所以在 DOM 里 textContent 永远是空的 —— 数字只活在样式表里。写脚本的人不用管这一层：base64 解开就是数字。

完整脚本#

见 参考代码/s13.py。核心就三行：

1
m = build_m(page)                                    # md5(page + 毫秒 + 盐) + "_" + 秒
2
payload = session.get(DATA_PATH, params={"page": page}, headers={"m": m}).json()
3
total += sum(int(base64.b64decode(row["value"])) for row in payload["data"])

跑出来：

1
共 5 页（页面只放出前 4 页），每页 10 条
2
第 1 页：10 条，本页合计 11111
3
...
4
五页票价总和：65635（提交这个数字）

排查清单#

403 请求凭据无效或已过期：盐不对 / 页码没参与签名 / 时间戳用了秒（参与摘要的必须是毫秒）/ 本机时间与服务器差太多。
浏览器报 String contains non ISO-8859-1 code point：请求头里放了非 ASCII（比如中文括号）。
一开 F12 就断：Ctrl+F8 停用断点，或给 Function 打补丁。
自己 new Function(payload) 报 SyntaxError：函数体要先 atob 解码；另外 Function 的最后一个参数才是函数体，前面的都是形参名（别把 base64 当形参名传）。
页面价格是空白：正常现象 —— 数字在 CSS 里（mv-digit 的 ::before）。用 getComputedStyle(el, '::before').content 才能看到。

常见问题#

Q：这算”反爬”还是”反调试”？ A：这几种手法在真实站点里通常一起出现（机票、电商比价那类页面尤其多）：拖慢你读代码的速度，同时用签名保证请求是”当场生成”的。

Q：为什么非要 md5 不可？ A：它只是个便宜的摘要：既能让服务端判断”这个请求是照着我的算法生成的”，又不至于像 HMAC 那样给客户端一把真钥匙（客户端 JS 里的东西都能被扒出来，本质上是”提高门槛”，不是”绝对安全”）。

Q：既然盐能扒出来，签名还有意义吗？ A：有。它把”随便构造请求”变成”你得先看懂我的 JS”，并且配合时间戳让旧签名很快失效。

最后提醒#

这些手段只适合在授权范围内的练习环境里研究。真实站点有服务条款和技术措施保护，绕过它们可能违法。

Python 爬虫入门实战：服务端渲染页面怎么取数（CH-001）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 1 关的解密教程。它练的不是「怎么破加密」，而是先判断数据到底在哪：这一关的数据只在服务端渲染出来的 HTML 里，源码里没有接口。答案是第一页 HTML 源码的字符数。

先搞清楚这一关在考什么#

前几关的坑通常藏在接口里，这一关反过来：页面是 Jinja2 服务端渲染的，电影数据直接写进了 HTML 源码。

所以拿到数据的方式只有一个：把页面请求下来，读源码。

但答案不是「抓到了哪些电影」，而是第一页源码有多少个字符。也就是说：

请求 GET /playground/movies/static（不加参数就是第 1 页）；
把响应体当成文本（不是字节）数长度；
把数字提交到挑战广场。

现象：源码里全是数据#

浏览器打开靶场页 /playground/movies/static，页面上是电影卡片。右键「查看网页源代码」，能看到 <li> 里直接写着电影名、评分、评价人数：

1
<li class="movie-item">
2
  <h3 class="movie-title">肖申克的救赎</h3>
3
  <span class="movie-rating">9.7</span>
4
  <span class="movie-rating-count">3235402人评价</span>
5
</li>

Network 面板里只有一个 document 请求，没有 XHR。这就说明数据在 HTML 里，而不是接口里。

三个最容易数错的地方#

写法	数出来的是什么	对不对
`len(response.text)`	解码后字符数	✅ 这一关要的就是这个
`len(response.content)`	原始字节数（UTF-8 中文一个字 3 字节）	❌ 会大好几倍
`len(response.text.strip())`	去掉了首尾空白	❌ 少几十个字符

还有一个隐蔽的坑：编码。如果 response.encoding 猜错了（比如把 UTF-8 当 ISO-8859-1），response.text 会变成乱码，字符数也就跟着错。

服务端已经声明了 Content-Type: text/html; charset=utf-8，正常情况下 requests 会照用。求稳可以显式指定：

1
response.encoding = "utf-8"

完整脚本#

1
"""CH-001：答案 = 第一页 HTML 源码的字符数"""
2
import sys
3

4
import requests
5

6
BASE = "https://spider.jsnote.top"
7
PAGE_URL = f"{BASE}/playground/movies/static"
8

9
headers = {
10
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
11
    "Accept-Language": "zh-CN,zh;q=0.9",
12
    "User-Agent": (
13
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
14
        "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36"
15
    ),
16
}
17

18
response = requests.get(PAGE_URL, headers=headers, timeout=10)
19
response.raise_for_status()
20
response.encoding = "utf-8"          # 显式指定，避免猜错编码导致字符数不对
21

22
html = response.text
23
print("状态码：", response.status_code)
24
print("Content-Type：", response.headers.get("Content-Type"))
25
print("源码字符数：", len(html))
26
print("源码字节数（对比用）：", len(response.content))
27
print("页面里有没有电影名：", "movie-title" in html)
28

29
if len(sys.argv) > 1:
30
    # 顺手核对一下第一页有多少部电影
31
    print("电影卡片数：", html.count('class="movie-item"'))

展开收起

跑完把 源码字符数 提交到挑战广场的 CH-001 答题框即可。参考实现见 参考代码/s1.py。

顺手确认一下「第 2 页也这样」#

1
page2 = requests.get(PAGE_URL, params={"page": 2}, headers=headers, timeout=10)
2
print(len(page2.text))   # 和第一页长度不同，说明确实在分页

这一关只需要第一页；但确认「改了参数内容会变」是好习惯 —— 能避免你把一个静态的缓存页当成接口。

排查清单#

源码里搜页面上确定存在的字（电影名），搜得到 → 数据在 HTML 里。
数长度前先确认 response.encoding，别让乱码影响字符数。
用 .text（字符）还是 .content（字节）先想清楚，两者差 2~3 倍。
不要 .strip()、不要 re.sub(r"\s+", "") —— 这一关答案要的就是原始长度。
提交答案要在登录状态下做。
如果数出来差一点点，先对比 len(html) 和 len(html.encode("utf-8"))，确认自己数的是字符。

常见问题#

为什么答案不是「电影数量」？#

题面写的是「第一页源码的字符数」。这类题让你先确认源码就是数据源，再确认你拿到的响应体完整、没被二次处理。

用 `requests.get(...).text` 和浏览器「查看源代码」长度一样吗？#

一样（前提是编码一致、没做 gzip 之外的额外转换）。浏览器 DevTools 里看到的换行是 \n，requests 也不会替你改成 \r\n。

需要登录吗？#

这一关的靶场页本身不需要登录，但提交答案要登录，所以脚本里要不要带 cookie 取决于你是想直接提交，还是只想算出数字。

最后提醒#

这关的数据是自己靶场的练习数据。真实站点里，服务端渲染页通常还带缓存与 CDN，抓之前先看 robots 与条款，控制频率。

去挑战广场提交答案，然后进 CH-002：数据会从源码里消失，只剩接口。

Python 爬虫接口实战：翻页取完再累加（CH-002）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 2 关的解密教程。这一关的数据不在 HTML 里，只能从分页接口拿；答案是全部电影「评分总人数」的累加值。重点是：怎么找到接口、怎么确认它没把总量直接给你、以及怎么把 21 页稳稳翻完。

现象：源码里没有数据了#

打开 /movies?challenge=CH-002，电影卡片正常显示。但「查看源代码」里搜不到任何一个电影名 —— 页面是 Vue 渲染的，数据只能来自 XHR。

F12 → Network → Fetch/XHR，刷新页面，会看到一个请求：

1
GET /api/movies?page=1&page_size=12

响应长这样（字段是精简过的）：

1
{
2
  "items": [
3
    {
4
      "title": "肖申克的救赎",
5
      "rating": 9.7,
6
      "rating_text": "9.7",
7
      "rating_count_text": "3235402人评价",
8
      "rating_count": 3235402
9
    }
10
  ],
11
  "page": 1,
12
  "page_size": 12,
13
  "total_movies": 249
14
}

接口故意不给你的东西#

/api/movies 不会下发整批统计字段：

字段	状态
`total_rating_score`（评分总和）	被剥掉了
`total_rating_count`（评价人数总和）	被剥掉了 ← 正是答案
`top_movie`（评分最高那部）	被剥掉了
`total_movies`（共多少部）	✅ 有，用来算要翻几页

所以「直接读一个字段就交卷」这条路被堵死了，必须一页一页取回来自己累加。

顺带说一句：page_size 上限是 100。想「一次要 1000 条」也会被服务端截回 100。

数据规模#

共 249 部电影，每页 12 条 → 21 页（最后一页可能不满）。
判断翻页结束的两种写法：page * page_size >= total_movies，或者某一页返回的 items 为空。

完整脚本#

1
"""CH-002：答案 = 全部电影「评分总人数」之和"""
2
import re
3
import time
4

5
import requests
6

7
BASE = "https://spider.jsnote.top"
8
API_URL = f"{BASE}/api/movies"
9
PAGE_SIZE = 12
10

11
session = requests.Session()
12
session.headers.update({
13
    "Accept": "application/json, text/plain, */*",
14
    "Accept-Language": "zh-CN,zh;q=0.9",
15
    "Referer": f"{BASE}/movies?challenge=CH-002",
16
    "User-Agent": (
17
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
18
        "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36"
19
    ),
20
})
21

22
# 数据是按账号派生的，所以要带登录态：
23
# 浏览器登录后 F12 -> Application -> Cookies -> 复制 session 的值
24
session.cookies.set("session", "<把浏览器里的 session cookie 粘到这里>",
25
                    domain="spider.jsnote.top")
26

27

28
def rating_count(movie):
29
    """优先用字段，字段缺失/为 0 时回头从 '3235402人评价' 里抠数字。"""
30
    count = movie.get("rating_count") or 0
31
    if count:
32
        return int(count)
33
    match = re.search(r"([\d,]+)\s*人评价", movie.get("rating_count_text", ""))
34
    return int(match.group(1).replace(",", "")) if match else 0
35

36

37
def main():
38
    page = 1
39
    total_movies = None
40
    total_count = 0
41
    movies = 0
42

43
    while True:
44
        response = session.get(
45
            API_URL, params={"page": page, "page_size": PAGE_SIZE}, timeout=10
46
        )
47
        response.raise_for_status()
48
        payload = response.json()
49

50
        items = payload.get("items", [])
51
        if not items:
52
            break
53

54
        total_movies = payload.get("total_movies", total_movies)
55
        for movie in items:
56
            total_count += rating_count(movie)
57
            movies += 1
58

59
        print(f"第 {page:>2} 页：{len(items)} 条，累计 {movies} 条，"
60
              f"评价人数小计 {total_count}")
61

62
        if total_movies and movies >= total_movies:
63
            break
64
        page += 1
65
        time.sleep(0.5)          # 别把靶场当压力测试
66

67
    print(f"\n共 {movies} 部电影，评价人数总和：{total_count}")
68

69

70
if __name__ == "__main__":
71
    main()

展开收起

把最后的数字提交到 CH-002 答题框即可。

排查清单#

源码里搜不到数据 → 打开 Network 的 Fetch/XHR，找首屏那个请求。
右键 → Copy as cURL，先在终端跑通一次，确认只差 Cookie。
看响应里有没有现成的总量字段；有就省事，没有就老老实实翻页。
翻页前先拿 total_movies 和 page_size 算出总页数，别写成死循环。
每页间隔 0.5s 以上。
解析用字段优先、文本兜底（rating_count 拿不到就正则 ([\d,]+)人评价）。
累加前把一千分隔符去掉（"1,234" → 1234）。
结束条件写成「取到的条数 ≥ 总数」或「这一页为空」，不要写「拿到 21 页」。

常见问题#

为什么我直接写 `page_size=1000` 也只能拿到 100 条？#

服务端有上限（min(100, max(1, page_size))），超了就按 100 处理。这是接口很常见的保护写法。

数据为什么每个人不一样？#

电影数据是共用的一份，但很多关卡的数据是按账号派生的（这道题的答案会不会变，取决于靶场实现）。所以别抄别人的答案，自己跑一遍。

需要登录吗？#

/api/movies 本身公开可读；提交答案必须登录。

只抓到 20 页就停了？#

说明结束条件写得不对：最后一页可能只有 9 条（不满 12 条），这时要停，但前面 20 页都是满的。用「累计条数 ≥ total_movies」判断最稳。

最后提醒#

翻页是很典型的「礼貌爬取」场景：按页取、留间隔、别并发轰炸。真实站点上，疯狂翻页最容易触发限流甚至封号。

去挑战广场提交，然后进 CH-003：数据不再是文本，而是一个你猜不到路径的文件。

Python 爬虫实战：随机下发路径的资源怎么下载（CH-003）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 3 关的解密教程。这一关要把图片下载下来，答案是这张图片的字节数。真正的考点是：拿到接口给的 image_id / image_url 之后，别把「字节」和「字符」搞混，也别拖太久（图片是随机下发的）。

现象：图片地址在页面源码里找不到#

在挑战广场点开 CH-003，抽屉里有一个「获取图片」按钮。点一下，页面会请求：

1
GET /api/challenges/CH-003/image

响应：

1
{
2
  "challenge_id": "CH-003",
3
  "image_id": "e33a1790898939fa",
4
  "image_url": "https://spider.jsnote.top/api/challenges/CH-003/image/e33a1790898939fa"
5
}

图片本体在 image_url 上，但它不是磁盘文件名：

磁盘上图片一直叫 challenge-01.jpg、challenge-02.jpg（稳定名字，方便维护）；
对外暴露的是随机的 image_id，接口用它反查磁盘文件再 send_file。

所以「猜路径下载」这条路是堵死的：每次都要先调一次接口拿 image_id + image_url。

目标是「字节数」不是「字符数」#

图片是二进制，正确姿势是 len(response.content)：

写法	结果
`len(response.content)`	✅ 图片真实字节数
`len(response.text)`	❌ 二进制被当文本解码，乱码 + 长度不对
`len(response.text.encode("utf-8"))`	❌ 双重编码，更长，而且可能报错

而且这次提交不只是填一个数字：还要带上 image_id，服务端要靠它找到你这一张图去核对大小。

完整脚本#

1
"""CH-003：答案 = 随机下发那张图片的字节数（提交时带 image_id）"""
2
import requests
3

4
BASE = "https://spider.jsnote.top"
5
PICK_URL = f"{BASE}/api/challenges/CH-003/image"
6

7
session = requests.Session()
8
session.headers.update({
9
    "Accept": "*/*",
10
    "Referer": f"{BASE}/",
11
    "User-Agent": (
12
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
13
        "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36"
14
    ),
15
})
16

17
# 图片是按「当前会话」下发的，并且提交要带登录态 —— 整个流程用一个 Session + 登录 cookie
18
session.cookies.set("session", "<把浏览器里的 session cookie 粘到这里>",
19
                    domain="spider.jsnote.top")
20

21

22
def main():
23
    # 1) 先让服务端发一张图
24
    pick = session.get(PICK_URL, timeout=10)
25
    pick.raise_for_status()
26
    data = pick.json()
27
    image_id = data["image_id"]
28
    image_url = data["image_url"]
29
    print("拿到图片：", image_id)
30

31
    # 2) 用返回的地址下载本体（别自己拼路径：路径就是随机 image_id）
32
    image = session.get(image_url, timeout=20)
33
    image.raise_for_status()
34

35
    size = len(image.content)                 # ⚠️ content（字节），不是 text（字符）
36
    print("Content-Type：", image.headers.get("Content-Type"))
37
    print("Content-Length（服务端声明的）：", image.headers.get("Content-Length"))
38
    print("实际字节数：", size)
39

40
    # 存的文件是个 JPEG：开头 FFD8
41
    print("文件头：", image.content[:4].hex())
42

43
    print(f"\n答案：{size}  （提交时 body 带上 image_id = {image_id}）")
44
    print("提交示例：POST /api/challenges/CH-003/submit "
45
          f'{{"answer": {size}, "image_id": "{image_id}"}}')
46

47

48
if __name__ == "__main__":
49
    main()

展开收起

为什么每一步都要在同一个 Session 里#

GET /api/challenges/CH-003/image 会把这张图片记进当前会话（session["ch003_image_id"]）：

如果你提交时没带 image_id，服务端会退回用会话里最近下发的那张 —— 换个 Session 就对不上了；
图片是随机下发的，再点一次「获取图片」就是另一张、另一个大小。

所以正确顺序是：拿图 → 立刻下载 → 立刻算大小 → 立刻提交。跨天再提交，很可能「图片对不上」。

排查清单#

别猜图片路径，先调 GET /api/challenges/CH-003/image。
用返回的 image_url 原样请求（它是绝对地址，服务端按当前请求算出来的）。
大小用 len(response.content)。
顺手打一下 Content-Length，和实际字节数对不上就先怀疑传输被截断。
检查文件头（JPEG 是 ffd8，PNG 是 89504e47），确认下下来的真是图片而不是错误页。
全流程放在一个 Session 里，别中途换 Cookie。
提交时带上 image_id。

常见问题#

为什么我下载下来的字节数和浏览器看到的文件大小不一样？#

先看是不是被 gzip 了（图片一般不会）。再看是不是拿 .text 数了字符 —— 二进制文件用文本方式读，长度必然不对。

同一张图片能反复下载吗？#

能，只要 image_id 还有效（challenge_images 表里登记着）。但大小是固定的，重复下载不会让答案变化；换个 image_id 才会变。

接口返回的 `image_url` 为什么是完整域名？#

服务端用 url_for(..., _external=True) 生成的，这样你在任何页面上都能直接拿去请求，不用自己拼域名。

最后提醒#

下载资源类接口在真实站点上通常带鉴权与防盗链（Referer 校验、临时签名 URL）。练习里只在自己的靶场跑；真实站点的图片请遵守版权与使用条款。

去挑战广场提交，然后进 CH-004：这次的伪装不在数据里，而在你的网络握手上。

Python 爬虫 TLS 指纹实战：requests 被挂住时怎么查（CH-004）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 4 关的解密教程。这一关的接口数据本身是明文 JSON，难点在你根本连不上：requests 会一直卡到超时，服务端什么都不返回。答案是 5 页共 50 条关键词的 CPC 之和（保留 2 位小数）。

现象：请求「不报错，也不返回」#

先按常规思路来：F12 找到接口，复制成 cURL，粘到终端跑：

Terminal window

1
curl "https://spider.jsnote.top/api/challenges/CH-004/cpc?page=1" -H "Cookie: session=..."

结果不是 403、不是 200，而是一直挂着，然后：

1
curl: (28) Operation timed out

这才是这一关真正的坑：服务端把连接挂住了（黑洞）。它不告诉你为什么，你只能自己判断。

顺手验证一下：浏览器打开靶场页 /cpc 完全正常。也就是说「浏览器能拿到，脚本拿不到」—— 那问题一定出在浏览器和脚本的差异上，而不是参数、Cookie、路径。

差异在哪：TLS 握手里的密码套件顺序#

HTTP 头可以伪造（UA、sec-ch-ua 随便抄），但 TLS 握手里的 ClientHello 抄不了：

客户端	首个密码套件
Python `requests` / `httpx` / `urllib3`（OpenSSL 默认）	`TLS_AES_256_GCM_SHA384`
Chrome / Edge	`TLS_AES_128_GCM_SHA256`
`curl`	视版本而定，多数也不是 Chrome 的顺序

服务端在 nginx 上把 $ssl_protocol / $ssl_ciphers / $ssl_curves 透传给了后端，后端口只看第一个套件：

含 AES256 → 判「不是浏览器」，把连接挂住；
AES128 / CHACha20 → 放行。

所以这不是「请求头问题」，也不是「代理问题」——HTTP 层根本没有机会参与。

两个容易踩的细节#

端口也有讲究：走 443（HTTPS）才有 TLS 指纹可谈。明文兜底端口 :5787 会直接返回「请通过 HTTPS（443 端口）访问本站」，因为那台机器上没有握手信息。
本地开发是例外：本机用 Vite 代理调试时，代理会预置三个 X-TLS-* 头模拟生产环境，所以本地能跑通；你用脚本直连本地后端反而会被判「不是 HTTPS」。本地想调试就把黑洞时长设成 0（LEARNSPIDER_TLS_TARPIT_SECONDS=0），它会退回 403，而不是挂你 100 秒。

解法：让握手长得像 Chrome#

最省事的是 curl_cffi：

Terminal window

1
pip install curl_cffi

它的 impersonate="chrome" 会把 ClientHello（套件顺序、扩展、曲线）整套伪装成 Chrome，服务端看第一个套件就是 TLS_AES_128_GCM_SHA256，直接放行。

完整脚本#

1
"""CH-004：答案 = 5 页 50 条关键词的 CPC 之和（保留 2 位小数）
2

3
为什么 requests 不行：
4
    requests 走 OpenSSL 默认套件顺序，ClientHello 首个套件是 TLS_AES_256_GCM_SHA384
5
    （Chrome 是 TLS_AES_128_GCM_SHA256）。服务端按首个套件判定客户端类型，
6
    不合规就把连接挂住（什么都不返回），所以你只能等到自己的 timeout。
7
    curl_cffi 的 impersonate="chrome" 连 ClientHello 一起伪装，才能拿到数据。
8
"""
9
from curl_cffi import requests
10

11
BASE = "https://spider.jsnote.top"
12
API_URL = f"{BASE}/api/challenges/CH-004/cpc"
13
TOTAL_PAGES = 5
14

15
headers = {
16
    "Accept": "application/json, text/plain, */*",
17
    "Accept-Language": "zh-CN,zh;q=0.9",
18
    "Referer": f"{BASE}/cpc?challenge=CH-004",
19
    "User-Agent": (
20
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
21
        "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36"
22
    ),
23
}
24

25
session = requests.Session(impersonate="chrome")     # 关键就这一行
26
session.headers.update(headers)
27
session.cookies.set("session", "<把浏览器里的 session cookie 粘到这里>",
28
                    domain="spider.jsnote.top")
29

30

31
def main():
32
    total = 0.0
33
    rows = 0
34
    for page in range(1, TOTAL_PAGES + 1):
35
        response = session.get(
36
            API_URL, params={"page": page}, timeout=20, impersonate="chrome"
37
        )
38
        response.raise_for_status()
39
        payload = response.json()
40
        items = payload.get("items", [])
41
        rows += len(items)
42

43
        page_sum = sum(float(item["cpc"]) for item in items)
44
        total += page_sum
45
        print(f"第 {page} 页：{len(items)} 条，本页 CPC 合计 {page_sum:.2f}，"
46
              f"累计 {total:.2f}")
47

48
    print(f"\n共 {rows} 条，CPC 总和：{round(total, 2)}")
49

50

51
if __name__ == "__main__":
52
    main()

展开收起

参考实现见 参考代码/s4.py。

排查清单#

请求「不报错也不返回」→ 先怀疑服务端黑洞，而不是自己网慢（把 timeout 设成 5 秒更快确认）。
浏览器能开、脚本不行 → 找两者差异：Cookie、请求头、TLS 指纹、HTTP 版本。
抄全套 HTTP 头没用 → 说明检查点在 TLS 层。
确认自己走的是 443 的 HTTPS，不是明文兜底端口。
用 curl_cffi 的 impersonate="chrome"（不是只改 UA）。
指纹合规了还是 401/403 → 这时候才轮到 Cookie 与参数。
接口一次只给一页，记得翻完 5 页（网页上只放出前 4 页）。
求和后保留 2 位小数（判题容差 0.05）。

常见问题#

我改了 User-Agent 和 sec-ch-ua，为什么还是卡住？#

因为那些是 HTTP 头。这一关看的是 TLS 握手里的东西，HTTP 层改什么都到不了判定逻辑。

为什么 curl 也不行？#

不同版本的 curl 用的是本地 OpenSSL 的套件顺序，多数情况下和 Chrome 不一致。要么升级/换 curl，要么直接用 curl_cffi。

`impersonate="chrome"` 会不会影响别的请求？#

只影响你显式声明的这个 Session。日常抓别的接口不必开，避免不必要的麻烦。

为什么判题的容差是 0.05？#

CPC 是两位小数浮点数，累加会有误差。留一点容差比要求「完全相等」更合理。

最后提醒#

TLS 指纹是真实存在的反爬手段（CDN、风控产品都在用）。它的意义是把「没有浏览器指纹的客户端」和「正常用户」分开 —— 逆向它属于学习范畴，滥用会直接影响服务方。

在自己的靶场里练，别拿去扫别人的站点。去挑战广场提交，然后进 CH-005：数据能拿到了，但每一条都要签名。

Python 爬虫接口签名实战：参数签名 + 会话绑定（CH-005）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 5 关的解密教程。这一关的接口参数要签名，而且取数只认一个「会话标识」（uuid）—— 这个 uuid 是页面自己生成的、并且已经在后端和你的账号绑定过。答案是 5 页共 50 个数字的总和。

现象：接口返回 `forbidden`，什么都不说#

打开靶场页 /numbers?challenge=CH-005，页面正常渲染出前 4 页数字。F12 → Network，取数请求长这样：

1
GET /api/challenges/CH-005/data?page=1&uuid=9f1c...&hash=8b1d...&t=1790936209983&s=XJ2026

四个看起来像随机的参数，外加一个固定值 s。手动去掉 hash 再发一次，得到的是：

1
{"error": "forbidden"}

没有「缺少参数」也没有「签名错误」——服务端故意什么都不说。这种时候就要回到页面自己的请求里找线索。

先看页面做了什么#

刷新靶场页时还有一个 POST 请求，它比取数接口更值得看：

1
POST /api/challenges/CH-005/session
2
{"uuid": "9f1c...(标准 UUID)"}

响应里会把页数信息给它。也就是说：

页面在浏览器里用 crypto.randomUUID() 生成一个 uuid；
调 /session 把这个 uuid 绑定到当前登录账号（这一步需要登录 Cookie）；
之后取数接口只认这个 uuid（不再要求登录 Cookie），并把「这一页的和」记在 uuid 名下。

这也解释了题面为什么要求「把 5 页都取一遍」：某页没取过，提交时会被点名。

签名怎么算#

签名算法同样在前端 bundle 里（NumbersChallengeView.vue），用 crypto.subtle.digest("SHA-256", ...) 算：

1
raw  = f"/numbers|{page}|{timestamp}|{salt}"     # 注意前导斜杠
2
hash = sha256(raw).hexdigest()                   # 十六进制，不是 Base64
3
t    = 毫秒时间戳
4
s    = "XJ2026"                                  # 就是盐本身，明文带在参数里
5
uuid = 页面生成、已经绑定过的那个

服务端比对时忽略大小写（hmac.compare_digest(digest.lower(), ...)）。

⚠️ 三个最容易翻车的地方：

坑	现象
`raw` 里少了前导斜杠（写成 `numbers\|...`）	永远 403
把摘要写成 Base64	永远 403
用别人（或另一个浏览器）的 uuid	403；提交时则是 409「不属于当前账号」

完整脚本#

1
"""CH-005：答案 = 5 页共 50 个数字的总和（提交时带 uuid）
2

3
两个关键点：
4
  1. 签名 raw 是 f"/numbers|{page}|{timestamp}|{salt}"，**带前导斜杠**，结果是 sha256 的 hex
5
  2. 取数只认 uuid —— 这个 uuid 要先由页面（或你）调 /session 绑定到账号
6
     （绑定那次请求需要登录 Cookie，之后取数就不需要了）
7
"""
8
import hashlib
9
import time
10
import uuid as uuid_lib
11

12
import requests
13

14
BASE = "https://spider.jsnote.top"
15
BIND_URL = f"{BASE}/api/challenges/CH-005/session"
16
DATA_URL = f"{BASE}/api/challenges/CH-005/data"
17
ROUTE = "/numbers"                  # 签名里的路径，带前导斜杠
18
SALT = "XJ2026"
19
TOTAL_PAGES = 5
20

21
session = requests.Session()
22
session.headers.update({
23
    "Accept": "application/json, text/plain, */*",
24
    "Referer": f"{BASE}/numbers?challenge=CH-005",
25
    "User-Agent": (
26
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
27
        "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36"
28
    ),
29
})
30
# 只有「绑定 uuid」这一步需要登录态
31
session.cookies.set("session", "<把浏览器里的 session cookie 粘到这里>",
32
                    domain="spider.jsnote.top")
33

34

35
def sign(page: int, timestamp: str, salt: str = SALT) -> str:
36
    raw = f"{ROUTE}|{page}|{timestamp}|{salt}"
37

38
    # 如果你怎么算都是 403，先打出来对一下服务端那行的哈希：
39
    #   sha256("/numbers|1|1790936209983|XJ2026")
40
    #        = 3a03b48eda815c1a0fac05d817831fa9d2787e836b47d0cfdbf7431e5f8a2a21
41
    return hashlib.sha256(raw.encode()).hexdigest()
42

43

44
def bind_account():
45
    """生成 uuid 并绑定到当前账号；页面就是这么干的。"""
46
    uuid_value = str(uuid_lib.uuid4())
47
    response = session.post(BIND_URL, json={"uuid": uuid_value}, timeout=10)
48
    if response.status_code == 401:
49
        raise SystemExit("绑定失败：这一步需要登录 Cookie")
50
    response.raise_for_status()
51
    print("已绑定 uuid：", uuid_value, response.json())
52
    return uuid_value
53

54

55
def main():
56
    uuid_value = bind_account()
57

58
    total = 0
59
    for page in range(1, TOTAL_PAGES + 1):
60
        timestamp = str(int(time.time() * 1000))
61
        response = session.get(DATA_URL, params={
62
            "page": page,
63
            "uuid": uuid_value,
64
            "hash": sign(page, timestamp),
65
            "t": timestamp,
66
            "s": SALT,
67
        }, timeout=10)
68

69
        if response.status_code == 403:
70
            raise SystemExit(
71
                "403：签名不对。自查 ——\n"
72
                '  · raw 是 "/numbers|<page>|<timestamp>|<salt>"（带前导斜杠）\n'
73
                "  · 摘要是 sha256 的 hex（不是 Base64）\n"
74
                "  · uuid 得是绑定过的那个"
75
            )
76
        response.raise_for_status()
77

78
        numbers = response.json()["numbers"]
79
        total += sum(numbers)
80
        print(f"第 {page} 页：{numbers} → 累计 {total}")
81
        time.sleep(0.5)
82

83
    print(f"\n答案：{total}")
84
    print("提交时记得带上同一个 uuid："
85
          f'POST /api/challenges/CH-005/submit {{"answer": {total}, "uuid": "{uuid_value}"}}')
86

87

88
if __name__ == "__main__":
89
    main()

展开收起

参考实现见 参考代码/s5.py（里面还留了「前导斜杠」那个坑的注释）。

为什么「只带 uuid、不带 Cookie」也能取数#

这是刻意设计的：绑定一次之后，uuid 就是这次采集会话的凭证。好处是采集脚本可以把 uuid 抄走、跨进程复用；坏处也一样 —— 因此有两条保护：

uuid 必须存在（没绑定过 → 403）；
提交答案时会核对 uuid 是否属于当前登录账号（不是自己的 → 409）。

所以别指望用别人的 uuid 交卷。

排查清单#

先看页面自己发的请求：除了取数接口，往往还有一个「初始化 / 绑定」接口。
403 且无解释 → 去前端 bundle 里搜签名关键词（sha256、subtle、hash）。
对一下 raw 字符串的每一段和分隔符（前导斜杠、竖线、字段顺序）。
确认摘要是 hex 还是 Base64 —— 这两者最容易混。
先取第 1 页打通，再写循环。
5 页都取过再提交（漏页会被点名）。
提交时带 uuid。
取数失败先分辨是 403（签名/uuid 问题）还是 503（后端 Redis 不可用）。

常见问题#

`t` 有时间校验吗？#

这一关的 t 只参与签名，服务端不校验时效（参考实现也是这么写的）。真实站点常常会校验时间窗口，所以养成「现算现用」的习惯没坏处。

为什么要设计成「uuid 绑定」？#

真实业务里，前端 SDK 会生成一个 sessionId / traceId 串起整段会话，后端用它做风控统计。这里是把它做成了「取数凭证」，让学员体会「会话标识也能成为一道门」。

少取一页会怎么样？#

提交时会返回 409，并明确告诉你缺第几页 —— 这个提示是故意给的，因为「漏页」不算攻击面。

最后提醒#

签名参数、会话凭证这类设计在真实站点上很常见，逆向它们时要清楚边界：只在自己的靶场或获得授权的目标上练习，别拿别人的接口做压力测试。

去挑战广场提交，然后进 CH-006：这次换一套古典密码，签名与响应都用「你认识的算法」重新包了一遍。

Python 爬虫加密实战：ROT + Base32 + 凯撒 + HMAC-MD5 组合（CH-006）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 6 关的解密教程。这一关把「古典密码」和「MAC 签名」拼在一起：请求参数要被 ROT-N 两次，响应要按 ROT47 → Base32 → 凯撒反着剥三层，签名则是 HMAC-MD5 再做两次 ROT-N。答案是 5 页共 50 个数字的总和。

现象：接口参数和响应都「不像人话」#

靶场页 /cipher?challenge=CH-006。F12 里能看到两个请求：

1) 取参数（GET）

1
GET /api/challenges/CH-006/init

1
{
2
  "rot13Offset": 7,
3
  "rot47Offset": 31,
4
  "caesarShift": 11,
5
  "salt": "9f2c1d0b7a4e5c88",
6
  "total_pages": 5,
7
  "visible_pages": 4,
8
  "page_size": 10
9
}

四个参数就是这一关的四把钥匙（按账号派生，同一个账号每次一样）。

2) 取数据（POST）

1
POST /api/challenges/CH-006/data
2
X-ROT-Sign: XywUaIsNnAvLxYdcIhSnyqcJBsDpvSJr
3
{"rotParams": "{\"Qwde\": 1, \"Wqjprx...\": ...}"}

响应：

1
{"encrypted": true, "rotData": "p&XmzB1#kQ...（一串 ASCII 可见字符）"}

签名头是字母混排（看着像凯撒），请求体和响应体都是可见字符但读不懂 —— 这就是典型的「古典密码套娃」。

四把钥匙分别管什么#

参数	用在哪
`rot13Offset`（1-25）	① 请求参数 JSON 做两次 ROT-N；② 签名摘要（hex）也做两次 ROT-N
`rot47Offset`（1-93）	响应体最外层：ASCII 33~126 的循环平移（ROT47 的推广）
`caesarShift`（1-25）	响应体最内层：对 Base32 解出来的 JSON 文本做凯撒
`salt`（16 位 hex）	HMAC-MD5 的密钥，同时也出现在签名 raw 里

两个必须记住的坑#

坑 1：ROT-N 做两次 ≠ 原样。 只有 N=13 时两次才会互相抵消（罗13表）。这里是 N=7、N=11 之类的值，所以：

1
rot_letters(rot_letters("hello", 7), 7)   # "spaar" —— 不是 hello

签名只能用 +N 做两遍（服务端就是这么算的），不能偷懒直接用 HMAC-MD5 的结果。

坑 2：Base32 解码要补齐填充。 去掉噪声字符后长度可能不是 8 的倍数，要自己补 =：

1
cleaned = "".join(c for c in text.upper() if c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567")
2
base64.b32decode(cleaned + "=" * ((-len(cleaned)) % 8))

响应是怎么加密的（正序）#

1
明文 JSON
2
  → 凯撒(caesarShift)          只动字母
3
  → Base32 编码                变成 A-Z2-7
4
  → ROT-N(rot47Offset)         在 ASCII 33~126 上平移 → 可见字符

解密就是反过来：ROT47 反向 → Base32 解码 → 凯撒反向 → json.loads。

完整脚本#

1
"""CH-006：答案 = 5 页共 50 个数字的总和"""
2
import base64
3
import hashlib
4
import hmac
5
import json
6
import time
7

8
import requests
9

10
BASE = "https://spider.jsnote.top"
11
ROUTE = "/cipher"                    # 签名里带前导斜杠
12
INIT_URL = f"{BASE}/api/challenges/CH-006/init"
13
DATA_URL = f"{BASE}/api/challenges/CH-006/data"
14
TOTAL_PAGES = 5
15
ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
16

17

18
# ---------- 三个基础变换 ----------
19
def rot_letters(text, offset):
20
    """凯撒 / ROT-N：只动字母，大小写各自成环（offset 允许为负 = 反向）。"""
21
    step = offset % 26
22
    out = []
23
    for char in str(text):
24
        if "a" <= char <= "z":
25
            out.append(chr((ord(char) - 97 + step) % 26 + 97))
26
        elif "A" <= char <= "Z":
27
            out.append(chr((ord(char) - 65 + step) % 26 + 65))
28
        else:
29
            out.append(char)
30
    return "".join(out)
31

32

33
def rot_printable(text, offset):
34
    """ROT-N over ASCII 33..126（ROT47 的推广）。"""
35
    step = offset % 94
36
    out = []
37
    for char in str(text):
38
        code = ord(char)
39
        out.append(chr((code - 33 + step) % 94 + 33) if 33 <= code <= 126 else char)
40
    return "".join(out)
41

42

43
def base32_decode(text):
44
    cleaned = "".join(char for char in str(text).upper() if char in ALPHABET)
45
    return base64.b32decode(cleaned + "=" * ((-len(cleaned)) % 8)).decode()
46

47

48
# ---------- 签名 / 参数 / 解密 ----------
49
def sign(config, page, timestamp):
50
    """HMAC-MD5(raw, salt) 的 hex，再做两次 ROT-N（N = rot13Offset）。"""
51
    raw = f"{ROUTE}|{page}|{timestamp}|{config['salt']}"
52
    digest = hmac.new(config["salt"].encode(), raw.encode(), hashlib.md5).hexdigest()
53
    offset = config["rot13Offset"]
54
    return rot_letters(rot_letters(digest, offset), offset)
55

56

57
def encode_params(config, page, timestamp):
58
    """参数是「两次 ROT-N 之后的 JSON 字符串」，直接当字段值发出去。"""
59
    raw = json.dumps({"page": page, "timestamp": timestamp}, separators=(",", ":"))
60
    offset = config["rot13Offset"]
61
    return rot_letters(rot_letters(raw, offset), offset)
62

63

64
def decrypt(config, rot_data):
65
    """ROT47 还原 → Base32 解码 → 凯撒还原 → JSON。"""
66
    unrotated = rot_printable(rot_data, -config["rot47Offset"])
67
    unbased = base32_decode(unrotated)
68
    return json.loads(rot_letters(unbased, -config["caesarShift"]))
69

70

71
def main():
72
    session = requests.Session()
73
    session.headers.update({
74
        "Content-Type": "application/json",
75
        "Referer": f"{BASE}/cipher?challenge=CH-006",
76
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/147.0.0.0 Safari/537.36",
77
    })
78
    session.cookies.set("session", "<把浏览器里的 session cookie 粘到这里>",
79
                        domain="spider.jsnote.top")
80

81
    config = session.get(INIT_URL, timeout=10).json()
82
    print("拿到钥匙：", {k: config[k] for k in
83
                      ("rot13Offset", "rot47Offset", "caesarShift", "salt")})
84

85
    total = 0
86
    for page in range(1, TOTAL_PAGES + 1):
87
        timestamp = str(int(time.time() * 1000))
88
        response = session.post(DATA_URL, headers={
89
            "X-ROT-Sign": sign(config, page, timestamp),
90
        }, data=json.dumps({
91
            "rotParams": encode_params(config, page, timestamp),
92
        }), timeout=10)
93

94
        if response.status_code == 403:
95
            raise SystemExit("403：签名不对。先确认 raw 是 '/cipher|page|timestamp|salt'，再做两遍 ROT-N")
96
        response.raise_for_status()
97

98
        payload = decrypt(config, response.json()["rotData"])
99
        numbers = payload["data"]
100
        total += sum(numbers)
101
        print(f"第 {page} 页：{numbers} → 累计 {total}")
102
        time.sleep(0.5)
103

104
    print(f"\n答案：{total}")
105

106

107
if __name__ == "__main__":
108
    main()

展开收起

参考实现见 参考代码/s6.py。

排查清单#

先拿 /init 的参数，别硬编码（每个账号不同）。
自己实现一遍三个变换，并用「正着加密、反着解密」自测一次。
签名 403 → 检查 raw 的四段拼接顺序与分隔符、摘要是不是 hex、ROT 是不是做了两遍。
解密报错 → 打印中间结果：unrotated 应该是 Base32 字符（A-Z2-7），不是的话说明 rot47Offset 用错了。
Base32 解码前先清洗字符（去掉 ?、空格、小写要转大写）并补 =。
参数 JSON 用 separators=(",", ":")（不要有空格），两边必须完全一致。
网页上只放出前 4 页，第 5 页必须靠接口。

常见问题#

这是真加密吗？#

不是。ROT/凯撒/Base32 都是编码或古典替换，没有密钥强度可言；它们的价值只是「挡一挡随手抓包的人」。真正能扛的是后面的 MAC 签名和会话校验。

为什么签名用 MD5 而不是 SHA-256？#

这里只是把常见套路凑齐。HMAC-MD5 作为 MAC 在「防篡改」场景仍然可用，但不要把它当哈希用在口令上（那是另一回事）。

`rot13Offset` 为什么叫这个名字？#

因为它就是 ROT-N 的偏移量，N=13 时正好是经典的 ROT13（自逆）。这里的 N 是随机的，所以不能自逆 —— 这就是第一个坑。

最后提醒#

学习加密伪装的目的，是能看懂、能定位、能写报告，而不是去构造攻击。靶场里随便试；真实站点上，抓取前先确认授权与规则。

去挑战广场提交，然后进 CH-007：数据会变成「一个字都看不到」的字体库映射。

Python 爬虫字体映射实战：HTML 里一个字都没有（CH-007）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 7 关的解密教程。这一关把大众点评那套「字体库 + 坐标」搬了过来：页面 HTML 里只有随机类名，文字全在字体库（SVG 文字地图）里，而「每个类名要把图挪多少像素」是接口加密下发的。目标是拿到 5 段古文、把它们各自的暗号字按页码拼起来。

现象：页面上有字，源码里没有字#

打开 /verse?challenge=CH-007，页面上是一段竖排/横排的古文。但「查看源代码」里搜不到任何一个正文词：

1
<span class="next-glyph cb68626"></span>
2
<span class="next-glyph c9ce688"></span>
3
...

每个字都是一个空的 span + 随机类名。字去哪了？去看 <head> 里多出来的两个东西：

1
<link rel="stylesheet" href="/playground/verse/glyph.css">
2
<style id="verse-glyph-positions">
3
  .cb68626{background-position:-0px -0px}
4
  .c9ce688{background-position:-20px -0px}
5
  ...
6
</style>

glyph.css 是静态的字体库样式：格子多大、背景图是哪张；
第二段 <style> 是页面运行时拼出来的，内容来自取数接口的响应 —— 这才是这一关的核心。

字体库长什么样#

/playground/verse/glyph.css

1
.next-glyph{display:inline-block;width:20px;height:26px;overflow:hidden;
2
            background-image:url('/playground/verse/glyphs.svg');background-repeat:no-repeat}
3
/* 背景图 800x208，每行 40 个字 */

/playground/verse/glyphs.svg

1
<svg xmlns="http://www.w3.org/2000/svg" width="800" height="208" viewBox="0 0 800 208">
2
  <text x="0" y="20" font-size="20" font-family="Songti SC, SimSun, serif">赋下托川白美禁然凌喜南荆各嫠而海未予波夫安绝世江 旗与中立耳侣游寄粟成甚鹿响蛟流酒</text>
3
  <text x="0" y="46" font-size="20" ...>口悲万纵星今和驾临共固棹扣歌羡曹上水色空；知天御’泛窈七诵吹酾子苏之间光况桂东藏</text>
4
  ...
5
</svg>

两个重要事实：

这张图里是整篇古文去重后的字符，顺序被打乱了（不是正文顺序）；
每个字占一格：宽 20px（= 字号，中文一个字正好一格）、高 26px，每行 40 个字。

所以「光有字体库」拼不出正文 —— 它只是一张字表，谁在哪一格要看接口给的坐标。

接口给了什么#

先看协议：这一关是 URL 编码 + HMAC-SHA256 + XOR 混合加密。三个请求/响应细节：

1
GET  /api/challenges/CH-007/init
2
  -> {"hmacKey": "…32 位 hex…", "xorKey": 137, "total_pages": 5, "visible_pages": 4}
3

4
POST /api/challenges/CH-007/data
5
  header  X-URL-Sign = base64(HMAC-SHA256(f"/verse|{page}|{timestamp}", hmacKey))
6
  body    {"params": <URL 编码后的 JSON 字符串>}
7
  响应    {"encrypted": true, "xorKey": 137,
8
           "data": <URL 编码( Base64( 逐字节 XOR(明文 JSON, xorKey) ) )>}

解密顺序（从外往里剥）：

1
URL 解码 → Base64 解码 → 逐字节 XOR(xorKey) → utf-8 → json.loads

解出来的明文没有正文、没有暗号字本身，只有「类名 + 坐标」：

1
{
2
  "page": 1,
3
  "layout": {"font_size": 20, "cell_width": 20, "line_height": 28, "chars_per_row": 15,
4
             "rows": 10, "padding": 14, "width": 328, "height": 308},
5
  "glyphs": [
6
    {"c": "cb68626", "x": 0,   "y": 0},
7
    {"c": "c9ce688", "x": 20,  "y": 0},
8
    {"c": "cf33753", "x": 40,  "y": 0}
9
  ],
10
  "key_index": 37
11
}

glyphs 数组的顺序 = 阅读顺序；
每个元素的 (x, y) = 这个字在字体库里的格子左上角坐标；
key_index = 暗号字排在第几位（从 0 数）；
layout 只是页面排版用的（字号/行距/每行几个字），跟字体库的格子无关 —— 别拿它算行列。

还原公式#

1
行 = y // 26          # 格子高
2
列 = x // 20          # 格子宽
3
字 = glyphs.svg 第 <行> 行文本的第 <列> 个字

按 glyphs 的顺序对每个元素做一遍，拼起来就是这一段原文。

完整脚本#

1
"""CH-007：答案 = 5 段各自的暗号字按页码拼起来（共 5 个字）"""
2
import base64
3
import hashlib
4
import hmac
5
import json
6
import re
7
import time
8
import urllib.parse
9

10
import requests
11

12
BASE = "https://spider.jsnote.top"
13
ROUTE = "/verse"
14
INIT_URL = f"{BASE}/api/challenges/CH-007/init"
15
DATA_URL = f"{BASE}/api/challenges/CH-007/data"
16
SHEET_CSS_PATH = "/playground/verse/glyph.css"     # 静态字体库样式（不需登录）
17
TOTAL_PAGES = 5
18

19

20
def sign(hmac_key, page, timestamp):
21
    """base64(HMAC-SHA256("/verse|page|timestamp", hmacKey))"""
22
    raw = f"{ROUTE}|{page}|{timestamp}"
23
    digest = hmac.new(hmac_key.encode(), raw.encode(), hashlib.sha256).digest()
24
    return base64.b64encode(digest).decode()
25

26

27
def encode_params(page, timestamp):
28
    return urllib.parse.quote(json.dumps({"page": page, "timestamp": timestamp},
29
                                        separators=(",", ":")), safe="")
30

31

32
def decrypt(url_encoded, xor_key):
33
    """URL 解码 → Base64 解码 → 逐字节 XOR → utf-8 → JSON"""
34
    masked = base64.b64decode(urllib.parse.unquote(url_encoded))
35
    plain = bytes(byte ^ xor_key for byte in masked)
36
    return json.loads(plain.decode("utf-8"))
37

38

39
def parse_font_map(session):
40
    """从静态字体库扒出格子宽高和一行一行的字。"""
41
    css = session.get(BASE + SHEET_CSS_PATH, timeout=10).text
42
    head = re.search(r"\.next-glyph\{([^}]*)\}", css).group(1)
43
    cell_w = int(re.search(r"width:(\d+)px", head).group(1))
44
    cell_h = int(re.search(r"height:(\d+)px", head).group(1))
45
    svg_path = re.search(r"url\('([^']+)'\)", head).group(1)
46

47
    svg = session.get(BASE + svg_path, timeout=10).text
48
    rows = re.findall(r"<text[^>]*>(.*?)</text>", svg, re.S)
49
    return cell_w, cell_h, rows
50

51

52
def decode(glyphs, cell_w, cell_h, rows):
53
    """坐标 → 行/列 → 字。"""
54
    chars = []
55
    for glyph in glyphs:
56
        row = glyph["y"] // cell_h
57
        col = glyph["x"] // cell_w
58
        chars.append(rows[row][col])
59
    return "".join(chars)
60

61

62
def main():
63
    session = requests.Session()
64
    session.headers.update({
65
        "Content-Type": "application/json",
66
        "Referer": f"{BASE}/verse?challenge=CH-007",
67
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/147.0.0.0 Safari/537.36",
68
    })
69
    session.cookies.set("session", "<把浏览器里的 session cookie 粘到这里>",
70
                        domain="spider.jsnote.top")
71

72
    config = session.get(INIT_URL, timeout=10).json()
73
    cell_w, cell_h, rows = parse_font_map(session)
74
    print(f"字体库：格子 {cell_w}x{cell_h}，{len(rows)} 行\n")
75

76
    keys = []
77
    for page in range(1, TOTAL_PAGES + 1):
78
        timestamp = str(int(time.time() * 1000))
79
        response = session.post(DATA_URL, headers={
80
            "X-URL-Sign": sign(config["hmacKey"], page, timestamp),
81
        }, data=json.dumps({"params": encode_params(page, timestamp)}), timeout=10)
82

83
        if response.status_code == 403:
84
            raise SystemExit("403：签名不对。自查 —— raw 是 '/verse|page|timestamp'，"
85
                             "结果是 HMAC-SHA256 的 Base64，路径带前导斜杠")
86
        response.raise_for_status()
87

88
        body = response.json()
89
        payload = decrypt(body["data"], int(body["xorKey"]))
90
        glyphs = payload["glyphs"]
91

92
        text = decode(glyphs, cell_w, cell_h, rows)
93
        key = decode([glyphs[payload["key_index"]]], cell_w, cell_h, rows)
94
        keys.append(key)
95
        print(f"第 {page} 段：{len(text)} 字 → 暗号字「{key}」")
96
        print(f"          开头：{text[:24]}…")
97
        time.sleep(0.5)
98

99
    print(f"\n答案：{''.join(keys)}")
100

101

102
if __name__ == "__main__":
103
    main()

展开收起

参考实现见 参考代码/s7.py。

排查清单#

源码里搜不到正文 → 看 <head> 里有没有 @font-face、background-image、动态 <style>。
找到静态字体库（glyph.css / glyphs.svg），先把格子宽高和每行字数弄清楚。
别用页面排版参数算行列（layout.line_height 和字体库格子高是两回事）。
签名 403 → 检查 raw 是否 "/verse|page|timestamp"、结果是否 Base64。
解密报错 → 记住顺序是 URL → Base64 → XOR → utf-8，XOR 的 key 是响应里的 xorKey（不在 init 里）。
坐标是格子左上角，直接整除格子宽高即可，别做四舍五入。
字体库顺序是打乱的：不要试图按顺序读图。
网页只放出前 4 段，第 5 段必须调接口。

常见问题#

为什么不用 `@font-face` 而是背景图？#

真实站点两种都有：@font-face 靠字体文件的 cmap 做映射，背景图靠 background-position 做映射。这一关用的是第二种（更容易看清「坐标」这件事）。想练第一种，看下一关 CH-008。

字体库能提前缓存吗？#

可以，它是静态的、和账号无关。但坐标是加密下发的、每个账号不同，所以缓存字体库只能省一次请求，不能省解密。

为什么我的第 5 段总取不到？#

网页上的分页标签只有 4 个（第 5 个是 disabled）。要拿第 5 段，必须自己构造请求 —— 这正是「页面上看不到的页，脚本才看得到」的练习点。

最后提醒#

字体映射是电商、点评类站点最常用的数字/文字保护手段之一。学会它就是学会「怎么把视觉还原成数据」；用的时候请遵守目标站点的规则与数据授权。

去挑战广场提交，然后进 CH-008：字体还在，但这次换成了真正的「字体文件 + 码位」。

Python 爬虫字体加密实战：码位混淆 + 自定义字体文件（CH-008）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 8 关的解密教程。这一关是真正的字体加密：价格和销量是一串 Uncode 私有区字符（\ue1a2），站点用「字体文件」说明每个码位的字形长什么样。目标是还原 30 件商品的价格/销量，提交价格总和（保留 2 位小数）。

现象：价格栏里没有数字#

打开 /font?challenge=CH-008，表格里商品名正常，价格和销量看起来也正常。但用控制台读文本：

1
document.querySelectorAll('.notice tbody tr')[0].querySelectorAll('td')[2].textContent
2
// "\ue1a2\ue867\uea85\ue263\uf63c\ue57b"   ← 一串私有区字符

1
Array.from(document.querySelectorAll('span.font-glyph')).slice(0,3).map(s => s.className)
2
// ["font-glyph ge1a2", "font-glyph ge867", "font-glyph gea85"]

三点确认这是「字体加密」而不是编码问题：

字符是合法的 Unicode 字符（私有区 U+E000~U+F8FF），只是没有语义；
页面上看得见数字 —— 说明有东西把它们画出来了；
那个东西是 CSS 背景图 + 字体文件，不是 response.encoding 的问题。

（对照第 7 关：CH-007 是类名 + 静态字形图；这一关多了一份按账号派生的字体文件做中间层。）

三层结构#

① 页面 HTML：只有码位 + 类名，没有数字。

1
<span class="font-glyph ge1a2">&#xE1A2;</span><span class="font-glyph ge867">&#xE867;</span>

② 字形图（静态、全站公用）

/playground/verse/font/digits.css

1
.font-glyph{display:inline-block;width:16px;height:20px;overflow:hidden;color:transparent;
2
            background-image:url('/playground/verse/font/digits.svg');background-repeat:no-repeat}

1
<!-- /playground/verse/font/digits.svg：0-9 和 .,+-，打乱顺序，一格一个 text -->
2
<text x="0" y="16" font-size="16">6</text>
3
<text x="16" y="16" font-size="16">1</text>
4
<text x="32" y="16" font-size="16">9</text>

③ 字体文件（按账号派生，公开可下载）

GET /api/challenges/CH-008/data 会给出 font_url：

1
{
2
  "font_url": "/playground/verse/font/23-3f1a9c0b2e.svg",
3
  "row_count": 30,
4
  "rows": [{"name": "云南普洱饼", "price": "\ueb02\ue867…", "sales": "\ue3c0…"}]
5
}

/playground/verse/font/23-3f1a9c0b2e.svg

1
<svg xmlns="http://www.w3.org/2000/svg"><defs>
2
  <font id="LSFont" horiz-adv-x="16">                                  <!-- 格子宽 16 -->
3
    <font-face font-family="LSFont" units-per-em="20" ascent="16" descent="-4"/>  <!-- 格子高 20，基线在格子里 16 处 -->
4
    <glyph unicode="&#xEB02;" d="M80 16 L96 16 L96 36 L80 36 Z"/>
5
    <glyph unicode="&#xE867;" d="M0 36 L16 36 L16 56 L0 56 Z"/>
6
  </font>
7
</defs></svg>

d 里那个矩形的左上角 (x, y) 就是这个码位对应字形在字形图里的落点。

真字体的 d 是矢量轮廓；这里简化成了「落点框」，但需要你做的事没变：把字体信息和字形图对上。

还原公式#

1
码位 → 字体里的 (x, y) → 在字形图里找同一个 (x, y) 的那个字

如果想按行列取（也可以）：

1
列 = x // 16
2
行 = (y - ascent) // 20        # ascent = 16，来自 <font-face>

完整脚本#

1
"""CH-008：答案 = 30 件商品价格之和（保留 2 位小数）
2

3
要点：
4
  1. 价格/销量是私有区码位，每个字符实例一个独立码位（同一个 8 在不同位置也不同）
5
     —— 所以频率统计没用，必须一个码位一个码位查字体
6
  2. 字体文件按账号派生（URL 里带短签），别人的字体对不上你的码位
7
  3. 字体里的 (x, y) 是「字形在字形图里的落点」，字形图里的 <text> 用的是同一个坐标
8
"""
9
import re
10

11
import requests
12

13
BASE = "https://spider.jsnote.top"
14
DATA_URL = f"{BASE}/api/challenges/CH-008/data"
15
SHEET_CSS_PATH = "/playground/verse/font/digits.css"
16

17
session = requests.Session()
18
session.headers.update({
19
    "Accept": "*/*",
20
    "Referer": f"{BASE}/font?challenge=CH-008",
21
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/147.0.0.0 Safari/537.36",
22
})
23
session.cookies.set("session", "<把浏览器里的 session cookie 粘到这里>",
24
                    domain="spider.jsnote.top")
25

26

27
def parse_font(text):
28
    """字体文件 -> (格子宽, 格子高, 基线高度, {码位: (x, y)})。"""
29
    cell_w = int(re.search(r'horiz-adv-x="(\d+)"', text).group(1))
30
    cell_h = int(re.search(r'units-per-em="(\d+)"', text).group(1))
31
    ascent = int(re.search(r'ascent="(\d+)"', text).group(1))
32

33
    cmap = {}
34
    for hex_code, path in re.findall(r'<glyph unicode="&#x([0-9A-Fa-f]+);" d="([^"]+)"/>', text):
35
        numbers = [int(value) for value in re.findall(r"-?\d+", path)]
36
        cmap[int(hex_code, 16)] = (numbers[0], numbers[1])
37
    return cell_w, cell_h, ascent, cmap
38

39

40
def parse_sheet(sess):
41
    """字形图 -> {(x, y): 字符}。"""
42
    css = sess.get(BASE + SHEET_CSS_PATH, timeout=10).text
43
    head = re.search(r"\.font-glyph\{([^}]*)\}", css).group(1)
44
    svg_path = re.search(r"url\('([^']+)'\)", head).group(1)
45

46
    svg = sess.get(BASE + svg_path, timeout=10).text
47
    cells = {}
48
    for x, y, char in re.findall(r'<text x="(-?\d+)" y="(-?\d+)"[^>]*>([^<])</text>', svg):
49
        cells[(int(x), int(y))] = char
50
    return cells
51

52

53
def decode(text, cmap, cells):
54
    """一串码位 -> 真数字。"""
55
    return "".join(cells[cmap[ord(char)]] for char in text)
56

57

58
def main():
59
    data = session.get(DATA_URL, timeout=10)
60
    if data.status_code == 401:
61
        raise SystemExit("401：这个接口要登录态（Cookie 没填对？）")
62
    data.raise_for_status()
63
    payload = data.json()
64

65
    font = session.get(BASE + payload["font_url"], timeout=10).text
66
    cell_w, cell_h, ascent, cmap = parse_font(font)
67
    cells = parse_sheet(session)
68
    print(f"字体：格子 {cell_w}x{cell_h}（ascent {ascent}），{len(cmap)} 个码位；"
69
          f"字形图 {len(cells)} 格\n")
70

71
    total = 0.0
72
    for index, row in enumerate(payload["rows"], start=1):
73
        price = decode(row["price"], cmap, cells)
74
        sales = decode(row["sales"], cmap, cells)
75
        total += float(price)
76
        if index <= 5:
77
            print(f"  {index:>2}. {row['name']}  价格 {price}  销量 {sales}")
78

79
    print(f"\n共 {len(payload['rows'])} 件商品，价格合计：{round(total, 2)}")
80

81

82
if __name__ == "__main__":
83
    main()

展开收起

参考实现见 参考代码/s8.py。

排查清单#

先确认「页面正常但 DOM 是私有区字符」—— 这是字体加密的典型现场，不是编码问题。
看元素的 font-family / 背景图，找到字形图和字体文件。
抓取接口（/api/challenges/CH-008/data）拿你自己账号的 font_url。
解析字体文件里的三个尺寸：horiz-adv-x（格子宽）、units-per-em（格子高）、ascent（基线）。
解析字形图，把 (x, y) → 字符 建成字典。
码位 → 字体里的 (x, y) → 查字典。用同一个坐标直接命中，别自己猜行列。
想按行列算就记住：行 = (y - ascent) // 格子高。
每个字符实例码位不同 → 别写「频率统计」那套。
求和后 round(..., 2)。

常见问题#

字体文件能给别人用吗？#

不能。它是按账号派生的：别人的字体里码位和你的码位不是一回事。所以别去抄别人的字体，直接取自己账号的。

为什么字体里的 `d` 是一个矩形，不是字形轮廓？#

这是靶场的简化：真字体里 d 是矢量轮廓，需要和标准字体做轮廓比对才能知道是哪个字。这里把「轮廓」换成了「落点框」，让你专注在「字体信息 + 字形图 → 字符」这条链路上。

为什么同一个数字有时能被 OCR 认出来？#

因为字形图里的数字本身是正常字体画的。你的眼睛（或者 ddddocr）看截图是能认出来的 —— 但正确做法是解析映射，不是截屏 OCR：截图方案在真实站点上会因为滚动、懒加载、多设备渲染而崩掉。

私有区字符会不会被 requests 弄坏？#

不会。它们是合法字符，只要 response.json() 正常解析就行。要留意的是别用 .encode("ascii") 之类的操作。

最后提醒#

字体加密是保护数字（价格、销量、票房）的常见手段。还原它属于「把视觉变成数据」，请在授权范围内使用：靶场随便试，真实站点先确认数据授权与抓取规则。

去挑战广场提交，然后进 CH-009：数据会换成「加密报文 + 每页都要过验证码」的那一套。

Python 爬虫验证码实战：AES 加密报文 + 每页算术验证码（CH-009）

Fri, 02 Oct 2026 10:46:38 GMT

本文是 LearnSpider 第 9 关的解密教程。这一关把政务站点常见的一套反爬凑齐了：请求/响应都是 AES-ECB 加密的 hex，还要带一个前端写死的 Adam-AppKey，而且每翻一页都得先过一道算术验证码。目标是取 10 页共 100 条备案公告，把每条批复文号最后一段数字加起来。

现象：报文是「一段十六进制」#

靶场页 /projects?challenge=CH-009，点页码会弹出验证码窗。F12 → Network 里最值得看的是两个请求：

1
POST /api/challenges/CH-009/captcha
2
Content-Type: application/json;charset=utf-8
3
Adam-AppKey: 3b08c9a1-924b-3876-9129-cca5976edfa9
4

5
<一段十六进制字符串>

响应也不是 JSON，而是另一段十六进制：

1
4f 2a 1b ... (hex)

用 JSON.parse 直接解析当然失败 —— 因为它是 AES 密文。这一关的代码里只要有一处顺序写错，你看到的就是「一堆乱码」。

三件事要同时做对#

环节	做法
报文加解密	AES-ECB + PKCS7，key = `Nr2bNQtm5o9A0qqz`（前端 JS 里）；请求体 = `AES(JSON).hex`，响应体也是 hex
访问凭证	请求头 `Adam-AppKey: 3b08c9a1-924b-3876-9129-cca5976edfa9`，不带就 403
验证码	每页一张、用后即焚：先 POST `/captcha` 拿图，算出 `8+2=?`，再把 `captchaId` + `yzm` 一起放进列表请求的参数里

解出来的结构（和真实站点一致）：

1
{
2
  "code": "0",
3
  "data": {
4
    "list": [
5
      {"projectName": "六安特安新能源…光伏电站项目",
6
       "projectCode": "2610-341504-04-01-309092",
7
       "itemName": "固定资产投资项目备案（内资项目）",
8
       "unitName": "六安市叶集区发展和改革委员会…",
9
       "approveResultName": "通过",
10
       "itemHandleTime": "2026/10/01 11:01:15"}
11
    ],
12
    "pageNumber": 1, "pageSize": 10,
13
    "totalPage": 10, "totalRow": 100,
14
    "firstPage": true, "lastPage": false
15
  },
16
  "message": "查询成功",
17
  "status": 200
18
}

展开收起

出错时 code 不是 "0"，例如验证码不对：

1
{"code": "1", "data": null, "message": "验证码错误或已过期", "status": 200}

验证码这一步最容易踩的坑#

每页一张、一次性的。想「先囤 10 张验证码再逐页用」不行 —— 每张用完即废。
识别算术题要宽容。8+2=? 里的 ? 经常被 OCR 认成 9（识别成 8+2=9），所以要用正则取前面那一段「数字 + 运算符 + 数字」：

1
re.search(r"(\d+)\s*([+\-*/])\s*(\d+)", normalised)   # 命中 8+2，忽略后面的噪声

认不出来就换一张重来，不要拿着一张坏图硬猜（会对不上，而且一直卡在同一张上）。

完整脚本#

1
"""CH-009：答案 = 10 页共 100 条批复文号「最后一段数字」之和
2

3
三道坎：
4
  1. 报文是 AES-ECB(PKCS7) 加密后的 hex：请求体自己加密，响应体自己解
5
  2. 请求头要带 Adam-AppKey
6
  3. 每翻一页都得先解一道算术验证码（一次性）
7
"""
8
import base64
9
import json
10
import re
11
import time
12

13
import requests
14
from Crypto.Cipher import AES
15
from Crypto.Util.Padding import pad, unpad
16

17
BASE = "https://spider.jsnote.top"
18
CAPTCHA_URL = f"{BASE}/api/challenges/CH-009/captcha"
19
LIST_URL = f"{BASE}/api/challenges/CH-009/list"
20
APP_KEY = "3b08c9a1-924b-3876-9129-cca5976edfa9"     # 前端写死的
21
AES_KEY = b"Nr2bNQtm5o9A0qqz"                        # 前端写死的
22
PAGE_SIZE = 10
23
MAX_PAGES = 10
24
MAX_RETRY = 6
25

26

27
def encrypt(payload: dict) -> str:
28
    """JSON -> AES-ECB(PKCS7) -> hex 文本（body 里放的就是这段 hex，不是 JSON）"""
29
    raw = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
30
    return AES.new(AES_KEY, AES.MODE_ECB).encrypt(pad(raw, AES.block_size)).hex()
31

32

33
def decrypt(hex_text: str) -> dict:
34
    """hex 文本 -> AES-ECB -> JSON"""
35
    clean = re.sub(r"\s+", "", str(hex_text))
36
    plain = unpad(AES.new(AES_KEY, AES.MODE_ECB).decrypt(bytes.fromhex(clean)),
37
                  AES.block_size)
38
    return json.loads(plain.decode("utf-8"))
39

40

41
session = requests.Session()
42
session.headers.update({
43
    "Accept": "*/*",
44
    "Adam-AppKey": APP_KEY,
45
    "Content-Type": "application/json;charset=utf-8",
46
    "Referer": f"{BASE}/projects?challenge=CH-009",
47
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/147.0.0.0 Safari/537.36",
48
    "X-Requested-With": "XMLHttpRequest",
49
})
50
session.cookies.set("session", "<把浏览器里的 session cookie 粘到这里>",
51
                    domain="spider.jsnote.top")
52

53

54
def call(url, payload) -> dict:
55
    response = session.post(url, data=encrypt(payload), timeout=20)
56
    if response.status_code == 401:
57
        raise SystemExit("401：需要登录态（Cookie 没填对？）")
58
    if not response.ok:
59
        raise SystemExit(f"{response.status_code}：{response.text[:200]}")
60
    return decrypt(response.text)
61

62

63
def solve_captcha(image_bytes: bytes) -> int:
64
    """识别 `8+2=?` 并算答案。"""
65
    import ddddocr                                            # pip install ddddocr
66

67
    text = ddddocr.DdddOcr(show_ad=False).classification(image_bytes)
68
    normalised = (text.replace("×", "*").replace("✕", "*").replace("╳", "*")
69
                      .replace("x", "*").replace("X", "*")
70
                      .replace("÷", "/").replace("／", "/"))
71
    match = re.search(r"(\d+)\s*([+\-*/])\s*(\d+)", normalised)
72
    if not match:
73
        raise ValueError(f"验证码没认出来：{text!r}")
74
    left, operator, right = int(match.group(1)), match.group(2), int(match.group(3))
75
    return {"+": left + right, "-": left - right, "*": left * right}.get(operator, left // right)
76

77

78
def fetch_page(page_number: int) -> dict:
79
    """取一页：每页都要先拿一张新验证码；识别失败或答错都换一张重来。"""
80
    last_message = ""
81
    for _attempt in range(MAX_RETRY):
82
        captcha = call(CAPTCHA_URL, {"ajaxRequestTimestamp": int(time.time() * 1000)})
83
        image_base64 = str(captcha["data"]["captchaImage"]).split(",")[-1]
84

85
        try:
86
            answer = solve_captcha(base64.b64decode(image_base64))
87
        except (ValueError, ImportError) as error:
88
            last_message = str(error)
89
            time.sleep(0.5)
90
            continue
91

92
        data = call(LIST_URL, {
93
            "ajaxRequestTimestamp": int(time.time() * 1000),
94
            "pageSize": PAGE_SIZE,
95
            "pageNumber": page_number,
96
            "nameOrCode": "",
97
            "queryType": "first",
98
            "selectType": "pname",
99
            "captchaId": captcha["data"]["captchaId"],
100
            "yzm": str(answer),
101
        })
102
        if data.get("code") == "0":
103
            return data["data"]
104

105
        last_message = f"{data.get('code')} {data.get('message')}"
106
        time.sleep(0.5)
107

108
    raise SystemExit(f"第 {page_number} 页连续 {MAX_RETRY} 次都没过：{last_message}")
109

110

111
def main():
112
    total = 0
113
    rows_seen = 0
114
    total_page = 0
115

116
    for page_number in range(1, MAX_PAGES + 1):
117
        page = fetch_page(page_number)
118
        total_page = int(page.get("totalPage") or 0)
119

120
        for row in page.get("list", []):
121
            tail = str(row["projectCode"]).rsplit("-", 1)[-1]      # 2610-341504-04-01-429215 -> 429215
122
            if tail.isdigit():
123
                total += int(tail)
124
                rows_seen += 1
125

126
        print(f"第 {page_number}/{total_page or '?'} 页：{len(page.get('list', []))} 条，"
127
              f"累计 {rows_seen} 条，小计 {total}")
128

129
        if page.get("lastPage") or page_number >= (total_page or MAX_PAGES):
130
            break
131

132
    print(f"\n共 {rows_seen} 条，批复文号末段数字之和：{total}")
133

134

135
if __name__ == "__main__":
136
    main()

展开收起

参考实现见 参考代码/s11.py；站点原始前端 JS（AES 那一段）存了一份 参考代码/s9.js。

排查清单#

响应不是 JSON → 先看响应体是不是 hex，是就说明要解密（别急着查编码）。
解密失败 → 检查 key 是不是前端写死的那个（在 bundle 里搜 AES、ECB、Pkcs7）。
403 且什么都不说 → 先看有没有带 Adam-AppKey。
携带 Adam-AppKey 之后响应变成 hex、不带你看到明文 JSON —— 说明这个头就是「加密模式」的开关（真实站点也这样）。
验证码：每页取一张；拿到图先算答案，再和 captchaId 一起提交。
OCR 认不全 → 用正则取「数字 + 运算符 + 数字」，别要求整串完全匹配。
识别失败/答错 → 换一张重来（写重试循环，别死磕一张图）。
翻页结束条件用响应的 lastPage / totalPage。
末段数字可能不是数字（脏数据）→ 先 isdigit() 再累加。

常见问题#

为什么请求体是 hex 文本，不是 JSON？#

因为前端用 CryptoJS 加密后直接当 body 发了（Content-Type 还写着 application/json;charset=utf-8，但那只是外观）。你在浏览器 DevTools 的 Payload 里看到的就是那段 hex。

只用 requests 能做验证码吗？#

能。这一关不需要浏览器：验证码是算术题图片，用 ddddocr 就能识别。真实站点上的点选、滑块、行为验证码才会需要浏览器自动化。

识别率不够高怎么办？#

三招：① 重试（最重要）；② 识别前对图片做放大/灰度化；③ 对答案做范围校验（比如结果不可能是负数或大于 100，落在这个范围外就换一张）。

为什么不干脆用 Playwright 一页页点？#

可以，但那会把「10 页 × 每题都要 OCR」的成本转移到浏览器上，而且慢。真实项目里更常见的是「请求级脚本 + OCR」，浏览器只用来观察。

最后提醒#

验证码设计的目的是把「人」和「脚本」分开。练习里我们训练识别能力，用它去理解「为什么单靠验证码挡不住有耐心的爬虫」；在真实站点上，请遵守对方的访问规则，控制频率，别做批量抓取。

去挑战广场提交，恭喜打通 9 关。

LearnSpider 笔记

第 15 关：蜜罐与爬虫封禁 —— 数据是假的，陷阱是真的

现象#

为什么「喂假数据」比「把门关上」更狠#

第一步：把「看不见的东西」找出来#

第二步：三类典型蜜罐（这一关全有）#

一、隐藏行（幽灵数据）#

二、隐藏链接（把爬虫往坑里带）#

三、隐藏表单字段（看着像统计参数）#

第三步：识别自己被「喂了假数据」#

第四步：被标记了怎么办#

第五步：完整脚本#

反爬方视角：蜜罐怎么设计才有效#

排查清单（⚠️ 先看前三条）#

FAQ#

第 14 关：Cookie 签名 —— 七层复合加密，和「密钥写在前端」这件事

现象#

分层：这一关要拆七层#

第一步：先把 Cookie 的用法搞清楚#

第二步：把混淆脚本扒开（只有两招障眼法）#

招式一：数字被写成了算术表达式#

招式二：字符串数组用的不是标准 base64 字母表#

第三步：把七层用 Python 复刻一遍#

第四步：怎么确认自己抄对了（不用猜）#

第五步：五页取齐，求和#

这一关真正要记住的：为什么「七层」不解决问题#

排查清单（⚠️ 先看前三条）#

FAQ#

第 13 关：点选验证码 + 一次一密的轨迹报文 + 行为风控

现象#

分层：这一关要拆五层#

第一步：先把流程和 challenge 的用法搞清楚#

第二步：认出图上的文字#

第三步：把 w 拼出来（一次一密在这儿）#

第四步：先过”环境”这一关 —— 自动化浏览器一进门就被认出来了#

第五步：最难的一关是”像个人”#

第六步：完整脚本#

排查清单（⚠️ 先看这一条）#

FAQ#

第 12 关：接口下发 JS + 字符串混淆 + 内置 MD5 + 反调试

现象#

分层：这次要拆的是”下发的代码”#

第一步：先把反调试按住#

第二步：把字符串表翻译出来#

第三步：解 qz（真正的数据）#

第四步：五页求和#

排查清单#

常见问题#

最后提醒#

第 10 关：RSA 传密钥 + AES 加密报文（顺带一层 JavaScript 混淆）

现象：请求头里有个看不懂的长串#

辨型：两段字符 = RSA 传密钥、AES 传报文#

定位资源：脚本里躺着的三件套#

还原公式#

完整脚本#

排查清单#

常见问题#

最后提醒#

第 11 关：无限 debugger + VM 混淆 + 签名请求头

现象#

分层：三层伪装，逐一剥#

第一步：让无限 debugger 闭嘴#

第二步：把盐挖出来#

第三步：复现签名#

第四步：票价（base64 + CSS）#

完整脚本#

排查清单#

常见问题#

最后提醒#

Python 爬虫入门实战：服务端渲染页面怎么取数（CH-001）

先搞清楚这一关在考什么#

现象：源码里全是数据#

三个最容易数错的地方#

完整脚本#

顺手确认一下「第 2 页也这样」#

排查清单#

常见问题#

为什么答案不是「电影数量」？#

用 requests.get(...).text 和浏览器「查看源代码」长度一样吗？#

需要登录吗？#

第三步：把 `w` 拼出来（一次一密在这儿）#

第三步：解 `qz`（真正的数据）#

用 `requests.get(...).text` 和浏览器「查看源代码」长度一样吗？#

为什么我直接写 `page_size=1000` 也只能拿到 100 条？#

接口返回的 `image_url` 为什么是完整域名？#

`impersonate="chrome"` 会不会影响别的请求？#

现象：接口返回 `forbidden`，什么都不说#

`t` 有时间校验吗？#

`rot13Offset` 为什么叫这个名字？#

为什么不用 `@font-face` 而是背景图？#