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

现象#

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

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

4. 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（页面没给它签）

5. Application → Cookies 里能看到那个 Cookie：

1
sign = 2v6ewxxz9cPu3Sp24OI_4K…

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

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

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

分层：这一关要拆七层#

七层里没有一层用到真正的秘密：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 的产物：控制流平坦化、十六进制变量名、死代码、字符串数组……别硬读。这个混淆器在这里其实只用了两招真正影响「能不能抄表」的手法：

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

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

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

第三步：把七层用 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)

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

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

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

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

1. F12 → Application → Cookies，把第 1 页那次请求的 sign 值抄下来；
2. 时间戳没法从 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)   # 提交这个总和

跑法：

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 公钥在前端、私钥在服务端）—— 那两关的「客户端多算一层」是为了不泄密，而不是为了加密给别人看。

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

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

FAQ#

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

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

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

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