赛事:第三届 PCTF2026 新生赛 | 方向:Crypto | 状态:已出 flag
Flag:PCTF{W3lc0me_t0_3rypt0_w0r14!_7c0203876682}
一、题目信息
| 项 | 内容 |
|---|---|
| 地址 | challenge1.pctf.top:30375(裸 TCP,不是 HTTP) |
| 考点 | 古典密码 / 数论 / 编码 共 9 类题型的脚本化自动作答 |
| 规则 | 每题 2 次机会,答错进度清零并重新抽题;连续答对 8 题给 flag |
9 类题型:Base64、Hex、Repeating-key XOR、CRT、Discrete Log、Modular Inverse、LCG 参数恢复、Caesar、Vigenère。
二、解题思路
- 服务是纯 TCP,banner 是
PCTF · 密码世界初始挑战,提示符为答案(剩余 N 次机会)>。 - 每题只有 2 次机会且答错清零,先只连不答采样 150 次(
discover.py),确认题库共 9 类、每类出现 ≥11 次,避免边做边猜。 - 针对 9 类各写一个求解器;解析用正则,整数答案支持
0x前缀,字符串不区分大小写。 - 增量 UTF-8 解码处理中文提示符被 TCP 分包截断的问题;每答完一题服务端只回「反馈 + 新题」,用 pending 缓冲只解析最新一段。
- 循环作答,直到响应里出现
PCTF{...}。
三、关键步骤
- 建连与读提示符:
socket.create_connection+codecs.getincrementaldecoder("utf-8"),累积到匹配答案(剩余\s*\d+\s*次机会)>\s*$为止。 - 各题型公式:
题型 解法 Base64 / Hex 解码后转小写 ASCII Repeating-key XOR 24-bit key 按 3 字节循环异或 CRT 两两互素同余式合并 Discrete Log BSGS(p≈7.7e6),最后 pow(g,x,p)==y自校验Modular Inverse pow(a, -1, m)LCG 差分求 a,回代求c,答案a,cCaesar 反向移位,下划线不变 Vigenère key 循环,下划线不消耗 key - 答题循环:解析 → 求解 →
sendall(ans+"\n"),最多 20 步;末尾再用[A-Za-z0-9_]+\{[^}\n]+\}兜底匹配 flag。
踩坑:最初用
"flag" in text判断结束,但完成页只写「奖励」不含英文 flag,导致多跑了几次;改成正则后一次通过。
四、拿到 Flag
PCTF{W3lc0me_t0_3rypt0_w0r14!_7c0203876682}五、Exp
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""密码世界初始挑战 自动作答
用法:python "Crypto - 密码世界初始挑战 - exp.py" [host] [port]
默认:challenge1.pctf.top 30375
"""
import base64
import codecs
import math
import re
import socket
import sys
import time
HOST = sys.argv[1] if len(sys.argv) > 1 else "challenge1.pctf.top"
PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 30375
PROMPT_RE = re.compile(r"答案(剩余\s*\d+\s*次机会)>\s*$")
FLAG_RE = re.compile(r"[A-Za-z0-9_]+\{[^}\n]+\}")
def log(*a):
print(*a, flush=True)
# ---------------- solvers ----------------
def crt2(r1, m1, r2, m2):
t = ((r2 - r1) * pow(m1, -1, m2)) % m2
return (r1 + m1 * t) % (m1 * m2)
def bsgs(g, y, p):
n = int(math.isqrt(p - 1)) + 1
table, e = {}, 1
for j in range(n):
table.setdefault(e, j)
e = (e * g) % p
factor = pow(g, p - 1 - n, p) # g^(-n)
gamma = y
for i in range(n + 1):
if gamma in table:
return i * n + table[gamma]
gamma = (gamma * factor) % p
return None
def solve(text):
m = re.search(r"\[\d+\]\s*([^\n]+)", text)
header = m.group(1) if m else ""
def one(pat):
mm = re.search(pat, text)
return mm.group(1) if mm else None
if "Base64" in header:
return "Base64", base64.b64decode(one(r"base64\s*=\s*([A-Za-z0-9+/=]+)")).decode("ascii").lower()
if "Repeating-key XOR" in header:
k = int(one(r"key\s*=\s*(0x[0-9a-fA-F]+|\d+)"), 0)
ct = bytes.fromhex(one(r"cipher_hex\s*=\s*([0-9a-fA-F]+)"))
for endian in ("big", "little"):
kb = k.to_bytes(3, endian)
pt = bytes(c ^ kb[i % 3] for i, c in enumerate(ct))
try:
s = pt.decode("ascii")
except UnicodeDecodeError:
continue
if re.fullmatch(r"[a-zA-Z_]+", s):
return "XOR", s.lower()
kb = k.to_bytes(3, "big")
return "XOR", bytes(c ^ kb[i % 3] for i, c in enumerate(ct)).decode("ascii", "replace").lower()
if "Hex" in header:
return "Hex", bytes.fromhex(one(r"hex\s*=\s*([0-9a-fA-F]+)")).decode("ascii").lower()
if "Discrete Log" in header:
p, g, y = int(one(r"p\s*=\s*(\d+)")), int(one(r"g\s*=\s*(\d+)")), int(one(r"y\s*=\s*(\d+)"))
x = bsgs(g, y, p)
assert x is not None and pow(g, x, p) == y
return "DLog", str(x)
if "Caesar" in header:
shift = int(one(r"shift\s*=\s*(\d+)"))
cipher = one(r"cipher\s*=\s*([a-z_]+)")
out = "".join(chr((ord(c) - 97 - shift) % 26 + 97) if c.isalpha() else c for c in cipher)
if not re.fullmatch(r"[a-z_]+", out):
out = "".join(chr((ord(c) - 97 + shift) % 26 + 97) if c.isalpha() else c for c in cipher)
return "Caesar", out
if "CRT" in header:
pairs = re.findall(r"x\s*≡\s*(\d+)\s*\(mod\s*(\d+)\)", text)
x = crt2(int(pairs[0][0]), int(pairs[0][1]), int(pairs[1][0]), int(pairs[1][1]))
return "CRT", str(x)
if "Vigenere" in header:
key = one(r"key\s*=\s*([a-z]+)")
cipher = one(r"cipher\s*=\s*([a-z_]+)")
out, k = [], 0
for c in cipher:
if c.isalpha():
out.append(chr((ord(c) - 97 - (ord(key[k % len(key)]) - 97)) % 26 + 97))
k += 1
else:
out.append(c)
return "Vigenere", "".join(out)
if "LCG" in header:
mm = int(one(r"\bm\s*=\s*(\d+)"))
x0, x1, x2 = (int(one(r"\bx%d\s*=\s*(\d+)" % i)) for i in range(3))
a = ((x2 - x1) * pow(x1 - x0, -1, mm)) % mm
c = (x1 - a * x0) % mm
return "LCG", "%d,%d" % (a, c)
if "Modular Inverse" in header:
a, mm = int(one(r"\ba\s*=\s*(\d+)")), int(one(r"\bm\s*=\s*(\d+)"))
return "ModInv", str(pow(a, -1, mm))
raise ValueError("unknown type: " + header)
# ---------------- network ----------------
class Conn:
def __init__(self):
self.s = socket.create_connection((HOST, PORT), timeout=15)
self.dec = codecs.getincrementaldecoder("utf-8")("replace")
self.pending = ""
self.all = ""
def read_prompt(self, timeout=25):
self.s.settimeout(timeout)
while True:
if PROMPT_RE.search(self.pending):
return self.pending
try:
chunk = self.s.recv(4096)
except socket.timeout:
return self.pending
if not chunk:
return self.pending
txt = self.dec.decode(chunk)
self.pending += txt
self.all += txt
def send(self, ans):
self.pending = ""
self.s.sendall((ans + "\n").encode())
def close(self):
try:
self.s.close()
except Exception:
pass
def run_once():
c = Conn()
try:
for step in range(20):
txt = c.read_prompt()
if not txt.strip():
log("empty prompt")
break
fm = FLAG_RE.search(txt)
if fm:
log("FLAG:", fm.group(0))
return fm.group(0)
typ, ans = solve(txt)
log("[step %d] %s -> %s" % (step, typ, ans))
c.send(ans)
time.sleep(0.15)
time.sleep(1.5)
try:
c.s.settimeout(5)
tail = c.dec.decode(c.s.recv(65536))
except Exception:
tail = ""
c.all += tail
mm = FLAG_RE.search(c.all)
return mm.group(0) if mm else None
finally:
c.close()
if __name__ == "__main__":
for attempt in range(6):
log("===== attempt %d =====" % (attempt + 1))
try:
flag = run_once()
except Exception as e:
log("ERROR:", repr(e))
flag = None
if flag:
log("GOT FLAG:", flag)
break
time.sleep(0.5)