mcp-test-authz 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.


This version of mcp-test-authz might be problematic. Click here for more details.

mcp_authz/__init__.py ADDED
@@ -0,0 +1,3 @@
1
+ from .server import mcp
2
+
3
+ __all__ = ["mcp"]
mcp_authz/_jwt.py ADDED
@@ -0,0 +1,81 @@
1
+ """极简 HS256 JWT 编解码(仅标准库)。
2
+
3
+ 本模块只做一件事:把「离线签发」与「本地校验」令牌所需的 HMAC-SHA256
4
+ 逻辑收敛到一处,且**不依赖 mcp / 任何第三方库**,便于单测与复用。
5
+
6
+ 生产建议:用 PyJWT,或改用非对称签名(RS256/ES256),资源侧只持有公钥。
7
+ """
8
+
9
+ from __future__ import annotations
10
+
11
+ import base64
12
+ import hashlib
13
+ import hmac
14
+ import json
15
+ import time
16
+
17
+
18
+ class JWTError(ValueError):
19
+ """令牌编解码或校验失败。"""
20
+
21
+
22
+ def _b64url_encode(raw: bytes) -> str:
23
+ return base64.urlsafe_b64encode(raw).rstrip(b"=").decode("ascii")
24
+
25
+
26
+ def _b64url_decode(seg: str) -> bytes:
27
+ pad = "=" * (-len(seg) % 4)
28
+ return base64.urlsafe_b64decode(seg + pad)
29
+
30
+
31
+ def _sign(signing_input: bytes, secret: str) -> str:
32
+ digest = hmac.new(secret.encode("utf-8"), signing_input, hashlib.sha256).digest()
33
+ return _b64url_encode(digest)
34
+
35
+
36
+ def encode(claims: dict, secret: str) -> str:
37
+ """用 HS256 把声明签发成 JWT。"""
38
+ header = {"alg": "HS256", "typ": "JWT"}
39
+ h = _b64url_encode(json.dumps(header, separators=(",", ":")).encode("utf-8"))
40
+ p = _b64url_encode(json.dumps(claims, separators=(",", ":")).encode("utf-8"))
41
+ return f"{h}.{p}.{_sign(f'{h}.{p}'.encode('ascii'), secret)}"
42
+
43
+
44
+ def decode(
45
+ token: str,
46
+ secret: str,
47
+ *,
48
+ issuer: str | None = None,
49
+ audience: str | None = None,
50
+ leeway: int = 0,
51
+ ) -> dict:
52
+ """校验 JWT 并返回声明;任一校验不通过都抛 JWTError。"""
53
+ parts = (token or "").split(".")
54
+ if len(parts) != 3:
55
+ raise JWTError("令牌格式不合法(应为 header.payload.signature)")
56
+ header_seg, payload_seg, sig_seg = parts
57
+ try:
58
+ header = json.loads(_b64url_decode(header_seg))
59
+ claims = json.loads(_b64url_decode(payload_seg))
60
+ except Exception as exc: # noqa: BLE001 - 解码失败统一转成 JWTError
61
+ raise JWTError(f"令牌解码失败:{exc}") from exc
62
+ if header.get("alg") != "HS256":
63
+ raise JWTError(f"不支持的签名算法:{header.get('alg')}")
64
+ if not hmac.compare_digest(_sign(f"{header_seg}.{payload_seg}".encode("ascii"), secret), sig_seg):
65
+ raise JWTError("令牌签名校验失败")
66
+
67
+ now = int(time.time())
68
+ exp = claims.get("exp")
69
+ if exp is not None and now > int(exp) + leeway:
70
+ raise JWTError("令牌已过期")
71
+ nbf = claims.get("nbf")
72
+ if nbf is not None and now + leeway < int(nbf):
73
+ raise JWTError("令牌尚未生效(nbf)")
74
+ if issuer is not None and claims.get("iss") != issuer:
75
+ raise JWTError(f"签发者不匹配:期望 {issuer},实际 {claims.get('iss')}")
76
+ if audience is not None:
77
+ aud = claims.get("aud")
78
+ aud_list = aud if isinstance(aud, list) else [aud]
79
+ if audience not in aud_list:
80
+ raise JWTError(f"受众不匹配:令牌 aud={aud},期望包含 {audience}")
81
+ return claims
mcp_authz/server.py ADDED
@@ -0,0 +1,391 @@
1
+ """鉴权探针(Stdio / UVX)—— 与 HTTP 版同构,覆盖 L1 / L2 / L3 三层鉴权
2
+
3
+ 定位(与 HTTP 版的差异)
4
+ ------------------------
5
+ HTTP 版通过**请求头**承载 L2 凭证,并按请求做中间件校验;Stdio 版没有入站 HTTP 传输
6
+ (平台用 `uvx` 拉起本进程,经 stdin/stdout 通信),因此:
7
+
8
+ - **L2 令牌经环境变量注入**:平台在 MCP 配置的 `env` 里下发令牌(`MCP_INBOUND_TOKEN`),
9
+ 本服务在进程内本地校验(HS256 + iss/aud),并按模式 `MCP_AUTH_MODE` 分支;
10
+ - **没有 `Authorization` 头冲突**:Stdio 不与平台走 HTTP,天然规避 1.4 所述的头名冲突;
11
+ - **L3 完全同构**:本服务仍按 `UPSTREAM_AUTH_MODE` 用**自己的**凭证访问上游。
12
+
13
+ 工具与 HTTP 版保持一致,便于对照测试:
14
+ whoami(回显 L2 身份) / auth_matrix(回显生效配置) / call_upstream(验证 L3 凭证)。
15
+
16
+ 环境变量(AgentArts Stdio 模式在配置的 `env` 中注入,不要写进代码/镜像)
17
+ ------------------------------------------------------------------------
18
+ L2:
19
+ - `MCP_AUTH_MODE` : none | apikey | jwt,默认 none
20
+ - `MCP_INBOUND_TOKEN` : 注入的入站凭证(jwt 模式为访问令牌;apikey 模式为被校验值)
21
+ - `MCP_INBOUND_APIKEY` : apikey 模式下的期望 Key(与上面比对)
22
+ - `MCP_AUTH_JWT_SECRET`: jwt 模式下的 HS256 验签密钥,缺失则 fail-closed
23
+ - `MCP_AUTH_ISSUER` : jwt 模式下期望的签发者 iss(可选,配置后强制校验)
24
+ - `MCP_AUTH_AUDIENCE` : jwt 模式下期望的受众 aud(可选,配置后强制校验)
25
+ L3:
26
+ - `UPSTREAM_AUTH_MODE` : static | client_credentials | token_exchange,默认 static
27
+ - `UPSTREAM_URL` : 上游基址,默认 http://127.0.0.1:9100
28
+ - `UPSTREAM_API_KEY` : static 模式下本服务访问上游的静态 Key
29
+ - `AS_TOKEN_URL` : 授权服务器令牌端点,默认 http://127.0.0.1:9000/token
30
+ - `OAUTH_CLIENT_ID` : 本服务的 OAuth client_id
31
+ - `OAUTH_CLIENT_SECRET`: 本服务的 OAuth client_secret
32
+ - `OAUTH_SCOPE` : 申请的 scope,默认 "demo:read demo:write"
33
+ - `OAUTH_ACTOR` : token_exchange 委派令牌中的 act(本服务身份)
34
+ - `OAUTH_AUDIENCE` : token_exchange 的 audience(上游资源标识)
35
+ """
36
+
37
+ from __future__ import annotations
38
+
39
+ import functools
40
+ import hmac
41
+ import json
42
+ import logging
43
+ import os
44
+ import threading
45
+ import time
46
+ import urllib.error
47
+ import urllib.parse
48
+ import urllib.request
49
+
50
+ from mcp.server import MCPServer
51
+ from mcp.server.mcpserver.exceptions import ToolError
52
+
53
+ from . import _jwt
54
+
55
+ logging.basicConfig(level=logging.INFO)
56
+ logger = logging.getLogger("authz-mcp-stdio")
57
+
58
+ # 创建 MCP 服务器实例 (v2: MCPServer)
59
+ mcp = MCPServer("authz-mcp-server")
60
+
61
+ # --------------------------------------------------------------------------- #
62
+ # 配置
63
+ # --------------------------------------------------------------------------- #
64
+ MCP_AUTH_MODE_ENV = "MCP_AUTH_MODE"
65
+ MCP_INBOUND_TOKEN_ENV = "MCP_INBOUND_TOKEN"
66
+ MCP_INBOUND_APIKEY_ENV = "MCP_INBOUND_APIKEY"
67
+ MCP_AUTH_JWT_SECRET_ENV = "MCP_AUTH_JWT_SECRET"
68
+ MCP_AUTH_ISSUER_ENV = "MCP_AUTH_ISSUER"
69
+ MCP_AUTH_AUDIENCE_ENV = "MCP_AUTH_AUDIENCE"
70
+
71
+ UPSTREAM_AUTH_MODE_ENV = "UPSTREAM_AUTH_MODE"
72
+ UPSTREAM_URL_ENV = "UPSTREAM_URL"
73
+ UPSTREAM_API_KEY_ENV = "UPSTREAM_API_KEY"
74
+ AS_TOKEN_URL_ENV = "AS_TOKEN_URL"
75
+ OAUTH_CLIENT_ID_ENV = "OAUTH_CLIENT_ID"
76
+ OAUTH_CLIENT_SECRET_ENV = "OAUTH_CLIENT_SECRET"
77
+ OAUTH_SCOPE_ENV = "OAUTH_SCOPE"
78
+ OAUTH_ACTOR_ENV = "OAUTH_ACTOR"
79
+ OAUTH_AUDIENCE_ENV = "OAUTH_AUDIENCE"
80
+
81
+ DEFAULT_MCP_AUTH_MODE = "none"
82
+ DEFAULT_UPSTREAM_AUTH_MODE = "static"
83
+ DEFAULT_UPSTREAM_URL = "http://127.0.0.1:9100"
84
+ DEFAULT_AS_TOKEN_URL = "http://127.0.0.1:9000/token"
85
+ DEFAULT_CLIENT_ID = "authz-mcp-client"
86
+ DEFAULT_CLIENT_SECRET = "authz-mcp-secret"
87
+ DEFAULT_SCOPE = "demo:read demo:write"
88
+ DEFAULT_ACTOR = "service:authz-mcp"
89
+ DEFAULT_AUDIENCE = "https://upstream.demo.example.com"
90
+
91
+ # RFC 8693 常量
92
+ TOKEN_EXCHANGE_GRANT = "urn:ietf:params:oauth:grant-type:token-exchange"
93
+ ACCESS_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:access_token"
94
+
95
+
96
+ def _env(name: str, default: str = "") -> str:
97
+ return os.getenv(name, default).strip()
98
+
99
+
100
+ def _mcp_auth_mode() -> str:
101
+ return _env(MCP_AUTH_MODE_ENV, DEFAULT_MCP_AUTH_MODE).lower()
102
+
103
+
104
+ def _upstream_auth_mode() -> str:
105
+ return _env(UPSTREAM_AUTH_MODE_ENV, DEFAULT_UPSTREAM_AUTH_MODE).lower()
106
+
107
+
108
+ def _upstream_url() -> str:
109
+ return _env(UPSTREAM_URL_ENV, DEFAULT_UPSTREAM_URL)
110
+
111
+
112
+ def _token_url() -> str:
113
+ return _env(AS_TOKEN_URL_ENV, DEFAULT_AS_TOKEN_URL)
114
+
115
+
116
+ def _client_id() -> str:
117
+ return _env(OAUTH_CLIENT_ID_ENV, DEFAULT_CLIENT_ID)
118
+
119
+
120
+ def _client_secret() -> str:
121
+ return _env(OAUTH_CLIENT_SECRET_ENV, DEFAULT_CLIENT_SECRET)
122
+
123
+
124
+ def _scope() -> str:
125
+ return _env(OAUTH_SCOPE_ENV, DEFAULT_SCOPE)
126
+
127
+
128
+ def _actor() -> str:
129
+ return _env(OAUTH_ACTOR_ENV, DEFAULT_ACTOR)
130
+
131
+
132
+ def _audience() -> str:
133
+ return _env(OAUTH_AUDIENCE_ENV, DEFAULT_AUDIENCE)
134
+
135
+
136
+ def _mask(token: str | None) -> str:
137
+ if not token:
138
+ return ""
139
+ if len(token) <= 16:
140
+ return "*" * len(token)
141
+ return f"{token[:8]}...{token[-6:]}(已脱敏)"
142
+
143
+
144
+ def _surface_errors(fn):
145
+ """兜底装饰器:把工具内未预期的异常转成 ToolError,让失败原因对模型可见。"""
146
+
147
+ @functools.wraps(fn)
148
+ def wrapper(*args, **kwargs):
149
+ try:
150
+ return fn(*args, **kwargs)
151
+ except ToolError:
152
+ raise
153
+ except Exception as exc: # noqa: BLE001 - 故意兜底,确保错误可见
154
+ logger.exception("工具 %s 执行异常", fn.__name__)
155
+ raise ToolError(f"{fn.__name__} 执行失败:{type(exc).__name__}: {exc}") from exc
156
+
157
+ return wrapper
158
+
159
+
160
+ # --------------------------------------------------------------------------- #
161
+ # L2:进程内本地校验(none / apikey / jwt)
162
+ # --------------------------------------------------------------------------- #
163
+ def _l2_inbound() -> dict:
164
+ """按 `MCP_AUTH_MODE` 校验 env 注入的入站凭证,返回上下文;失败一律抛 ToolError。"""
165
+ mode = _mcp_auth_mode()
166
+ if mode == "none":
167
+ return {"mode": "none"}
168
+
169
+ if mode == "apikey":
170
+ expected = _env(MCP_INBOUND_APIKEY_ENV)
171
+ if not expected:
172
+ raise ToolError(f"MCP_AUTH_MODE=apikey 但未配置 {MCP_INBOUND_APIKEY_ENV}(fail-closed)")
173
+ presented = _env(MCP_INBOUND_TOKEN_ENV)
174
+ if not hmac.compare_digest(presented, expected):
175
+ raise ToolError(f"入站 API Key 缺失或不正确:请在 env 注入 {MCP_INBOUND_TOKEN_ENV}")
176
+ return {"mode": "apikey", "credential": presented}
177
+
178
+ if mode == "jwt":
179
+ token = _env(MCP_INBOUND_TOKEN_ENV)
180
+ if not token:
181
+ raise ToolError(f"鉴权失败:未配置 {MCP_INBOUND_TOKEN_ENV}(入站访问令牌),请在 env 注入。")
182
+ secret = _env(MCP_AUTH_JWT_SECRET_ENV)
183
+ if not secret:
184
+ raise ToolError(f"鉴权失败:未配置 {MCP_AUTH_JWT_SECRET_ENV}(验签密钥),fail-closed。")
185
+ try:
186
+ claims = _jwt.decode(
187
+ token, secret,
188
+ issuer=_env(MCP_AUTH_ISSUER_ENV) or None,
189
+ audience=_env(MCP_AUTH_AUDIENCE_ENV) or None,
190
+ )
191
+ except _jwt.JWTError as exc:
192
+ raise ToolError(f"令牌校验失败:{exc}") from exc
193
+ return {"mode": "jwt", "credential": token, "token": token, "claims": claims}
194
+
195
+ raise ToolError(f"未知的 MCP_AUTH_MODE:{mode}")
196
+
197
+
198
+ def _subject_token() -> str:
199
+ """取得 L2 注入的用户令牌(供 token_exchange 使用)。"""
200
+ return _env(MCP_INBOUND_TOKEN_ENV)
201
+
202
+
203
+ # --------------------------------------------------------------------------- #
204
+ # L3:取上游凭证 —— static / client_credentials / token_exchange 三种模式
205
+ # --------------------------------------------------------------------------- #
206
+ _TOKEN_LOCK = threading.Lock()
207
+ _TOKEN_CACHE: dict = {"token": None, "exp": 0.0, "subject": None}
208
+
209
+
210
+ def _as_post(form: dict) -> dict:
211
+ data = urllib.parse.urlencode(form).encode("utf-8")
212
+ req = urllib.request.Request(
213
+ _token_url(), data=data, method="POST",
214
+ headers={"Content-Type": "application/x-www-form-urlencoded"},
215
+ )
216
+ try:
217
+ with urllib.request.urlopen(req, timeout=10) as resp:
218
+ return json.loads(resp.read().decode("utf-8"))
219
+ except urllib.error.HTTPError as exc:
220
+ detail = exc.read().decode("utf-8", "ignore")
221
+ raise ToolError(f"向授权服务器取令牌失败:HTTP {exc.code} {detail}") from exc
222
+ except ToolError:
223
+ raise
224
+ except Exception as exc: # noqa: BLE001
225
+ raise ToolError(f"向授权服务器取令牌失败:{type(exc).__name__}: {exc}") from exc
226
+
227
+
228
+ def _fetch_service_token(force: bool = False) -> str:
229
+ """client_credentials:用本服务自己的 client_id/secret 取令牌(带缓存/自动刷新)。"""
230
+ with _TOKEN_LOCK:
231
+ now = time.time()
232
+ if not force and _TOKEN_CACHE["token"] and _TOKEN_CACHE["exp"] - 30 > now:
233
+ return _TOKEN_CACHE["token"]
234
+ payload = _as_post({
235
+ "grant_type": "client_credentials",
236
+ "client_id": _client_id(),
237
+ "client_secret": _client_secret(),
238
+ "scope": _scope(),
239
+ })
240
+ token = payload.get("access_token")
241
+ if not token:
242
+ raise ToolError(f"授权服务器未返回 access_token:{payload}")
243
+ _TOKEN_CACHE.update({"token": token, "exp": now + float(payload.get("expires_in", 3600))})
244
+ logger.info("已取得服务令牌:client_id=%s scope=%s", _client_id(), payload.get("scope"))
245
+ return token
246
+
247
+
248
+ def _exchange_token(subject_token: str, force: bool = False) -> str:
249
+ """token_exchange(RFC 8693):用入站用户令牌换取委派令牌(带缓存/自动刷新)。"""
250
+ with _TOKEN_LOCK:
251
+ now = time.time()
252
+ if (
253
+ not force
254
+ and _TOKEN_CACHE["token"]
255
+ and _TOKEN_CACHE["subject"] == subject_token
256
+ and _TOKEN_CACHE["exp"] - 30 > now
257
+ ):
258
+ return _TOKEN_CACHE["token"]
259
+ payload = _as_post({
260
+ "grant_type": TOKEN_EXCHANGE_GRANT,
261
+ "client_id": _client_id(),
262
+ "client_secret": _client_secret(),
263
+ "subject_token": subject_token,
264
+ "subject_token_type": ACCESS_TOKEN_TYPE,
265
+ "audience": _audience(),
266
+ "scope": _scope(),
267
+ })
268
+ token = payload.get("access_token")
269
+ if not token:
270
+ raise ToolError(f"授权服务器未返回 access_token:{payload}")
271
+ _TOKEN_CACHE.update({
272
+ "token": token, "exp": now + float(payload.get("expires_in", 3600)), "subject": subject_token,
273
+ })
274
+ return token
275
+
276
+
277
+ def _l3_headers() -> tuple[dict, str]:
278
+ """按 `UPSTREAM_AUTH_MODE` 生成访问上游所需请求头,返回 (headers, 使用的模式)。"""
279
+ mode = _upstream_auth_mode()
280
+ if mode == "static":
281
+ key = _env(UPSTREAM_API_KEY_ENV)
282
+ if not key:
283
+ raise ToolError("UPSTREAM_AUTH_MODE=static 需要配置 UPSTREAM_API_KEY")
284
+ return {"X-Api-Key": key}, "static"
285
+ if mode == "client_credentials":
286
+ return {"Authorization": f"Bearer {_fetch_service_token()}"}, "client_credentials"
287
+ if mode == "token_exchange":
288
+ subject = _subject_token()
289
+ if not subject or _mcp_auth_mode() != "jwt":
290
+ raise ToolError(
291
+ "UPSTREAM_AUTH_MODE=token_exchange 需要 L2 提供用户令牌;"
292
+ "请将 MCP_AUTH_MODE 设为 jwt 并注入 MCP_INBOUND_TOKEN。"
293
+ )
294
+ return {"Authorization": f"Bearer {_exchange_token(subject)}"}, "token_exchange"
295
+ raise ToolError(f"未知的 UPSTREAM_AUTH_MODE:{mode}")
296
+
297
+
298
+ # --------------------------------------------------------------------------- #
299
+ # 工具(与 HTTP 版同名)
300
+ # --------------------------------------------------------------------------- #
301
+ @mcp.tool()
302
+ @_surface_errors
303
+ def whoami() -> dict:
304
+ """回显本次调用的 L2 身份信息(模式 / 令牌声明)。"""
305
+ inbound = _l2_inbound()
306
+ claims = inbound.get("claims") or {}
307
+ credential = inbound.get("credential", "")
308
+ return {
309
+ "l2_mode": inbound.get("mode", _mcp_auth_mode()),
310
+ "l2_source": MCP_INBOUND_TOKEN_ENV,
311
+ "credential_present": bool(credential),
312
+ "credential_preview": _mask(credential),
313
+ "inbound_claims": {
314
+ "sub": claims.get("sub"),
315
+ "iss": claims.get("iss"),
316
+ "aud": claims.get("aud"),
317
+ "client_id": claims.get("client_id"),
318
+ "scope": claims.get("scope"),
319
+ "act": claims.get("act"),
320
+ "exp": claims.get("exp"),
321
+ },
322
+ }
323
+
324
+
325
+ @mcp.tool()
326
+ @_surface_errors
327
+ def auth_matrix() -> dict:
328
+ """回显本服务当前生效的鉴权配置(L2 / L3 全量),用于快速核对 env 是否注入正确。"""
329
+ return {
330
+ "l2": {
331
+ "mode": _mcp_auth_mode(),
332
+ "token_env": MCP_INBOUND_TOKEN_ENV,
333
+ "token_configured": bool(_env(MCP_INBOUND_TOKEN_ENV)),
334
+ "apikey_configured": bool(_env(MCP_INBOUND_APIKEY_ENV)),
335
+ "jwt_secret_configured": bool(_env(MCP_AUTH_JWT_SECRET_ENV)),
336
+ "issuer": _env(MCP_AUTH_ISSUER_ENV) or None,
337
+ "audience": _env(MCP_AUTH_AUDIENCE_ENV) or None,
338
+ },
339
+ "l3": {
340
+ "mode": _upstream_auth_mode(),
341
+ "upstream_url": _upstream_url(),
342
+ "static_key_configured": bool(_env(UPSTREAM_API_KEY_ENV)),
343
+ "as_token_url": _token_url(),
344
+ "client_id": _client_id(),
345
+ "scope": _scope(),
346
+ "actor": _actor(),
347
+ "audience": _audience(),
348
+ },
349
+ "notes": {
350
+ "token_passthrough": False,
351
+ "l2_transport": "stdio: 平台在 env 注入令牌,进程内本地校验(无 HTTP 头冲突)",
352
+ "l1": "运行时端点鉴权由 AgentArts 网关负责,与本服务代码无关",
353
+ },
354
+ }
355
+
356
+
357
+ @mcp.tool()
358
+ @_surface_errors
359
+ def call_upstream(path: str = "/echo") -> dict:
360
+ """按 L3 模式取得凭证并调用上游,回显上游的鉴权结果(sub / act / scope / via)。
361
+
362
+ token_exchange 模式需搭配 L2 的 jwt 模式使用。
363
+
364
+ Args:
365
+ path: 上游路径,默认 /echo。
366
+ """
367
+ headers, via = _l3_headers()
368
+ req = urllib.request.Request(
369
+ _upstream_url().rstrip("/") + path, method="GET",
370
+ headers={**headers, "Accept": "application/json"},
371
+ )
372
+ try:
373
+ with urllib.request.urlopen(req, timeout=15) as resp:
374
+ payload = json.loads(resp.read().decode("utf-8"))
375
+ except urllib.error.HTTPError as exc:
376
+ detail = exc.read().decode("utf-8", "ignore")
377
+ raise ToolError(f"调用上游失败:HTTP {exc.code} {detail}") from exc
378
+ except ToolError:
379
+ raise
380
+ except Exception as exc: # noqa: BLE001
381
+ raise ToolError(f"调用上游失败:{type(exc).__name__}: {exc}") from exc
382
+ return {"l3_mode": via, "upstream_url": _upstream_url(), "upstream": payload}
383
+
384
+
385
+ def main() -> None:
386
+ """UVX 入口点 — 以 stdio 模式启动 MCP 服务"""
387
+ mcp.run(transport="stdio")
388
+
389
+
390
+ if __name__ == "__main__":
391
+ main()
@@ -0,0 +1,7 @@
1
+ Metadata-Version: 2.5
2
+ Name: mcp-test-authz
3
+ Version: 0.1.0
4
+ Summary: Authz probe MCP server (stdio) covering L2/L3 auth modes
5
+ License-Expression: MIT
6
+ Requires-Python: >=3.10
7
+ Requires-Dist: mcp>=2.0.0
@@ -0,0 +1,7 @@
1
+ mcp_authz/__init__.py,sha256=h6DgLFO4TMUk7_wCJ2jn2Y6IkFmfzb-Z7jX-G5UCYVc,43
2
+ mcp_authz/_jwt.py,sha256=l2PSh5lccZ6wL7N5Lf7QlA6wgLa0JthEAsnkt4_6lzo,2950
3
+ mcp_authz/server.py,sha256=a0vgRVRFO3yUdlRIZsIhM-6PGj57Un3C7zgmwoOhxg0,15278
4
+ mcp_test_authz-0.1.0.dist-info/METADATA,sha256=VOozh3ybdwgbXkL1F-SqYWz-bQBb8uowToc_YjCFeoA,198
5
+ mcp_test_authz-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
6
+ mcp_test_authz-0.1.0.dist-info/entry_points.txt,sha256=GwHcTIxJBLH09Y4UQ_whup9LNHkkGeafCAgyCGFLEFY,57
7
+ mcp_test_authz-0.1.0.dist-info/RECORD,,
@@ -0,0 +1,4 @@
1
+ Wheel-Version: 1.0
2
+ Generator: hatchling 1.33.0
3
+ Root-Is-Purelib: true
4
+ Tag: py3-none-any
@@ -0,0 +1,2 @@
1
+ [console_scripts]
2
+ mcp-test-authz = mcp_authz.server:main