Aleer
Aleer
发布于 2026-11-10 / 6 阅读
0
0

CRYPTO - 密码世界初始挑战

赛事:第三届 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。

二、解题思路

  1. 服务是纯 TCP,banner 是 PCTF · 密码世界初始挑战,提示符为 答案(剩余 N 次机会)>。
  2. 每题只有 2 次机会且答错清零,先只连不答采样 150 次(discover.py),确认题库共 9 类、每类出现 ≥11 次,避免边做边猜。
  3. 针对 9 类各写一个求解器;解析用正则,整数答案支持 0x 前缀,字符串不区分大小写。
  4. 增量 UTF-8 解码处理中文提示符被 TCP 分包截断的问题;每答完一题服务端只回「反馈 + 新题」,用 pending 缓冲只解析最新一段。
  5. 循环作答,直到响应里出现 PCTF{...}。

三、关键步骤

  1. 建连与读提示符:socket.create_connection + codecs.getincrementaldecoder("utf-8"),累积到匹配 答案(剩余\s*\d+\s*次机会)>\s*$ 为止。
  2. 各题型公式:
    题型解法
    Base64 / Hex解码后转小写 ASCII
    Repeating-key XOR24-bit key 按 3 字节循环异或
    CRT两两互素同余式合并
    Discrete LogBSGS(p≈7.7e6),最后 pow(g,x,p)==y 自校验
    Modular Inversepow(a, -1, m)
    LCG差分求 a,回代求 c,答案 a,c
    Caesar反向移位,下划线不变
    Vigenèrekey 循环,下划线不消耗 key
  3. 答题循环:解析 → 求解 → 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)

评论