Spaces:
Running
Running
Download _sec2_selftest.py from a3216/xtc-backend: direct link, hf CLI and curl.
- Browser
- Download file 18.4 kB
-
https://huggingface.co/spaces/a3216/xtc-backend/resolve/main/_sec2_selftest.py
- Command line
-
hf download hf://spaces/a3216/xtc-backend/_sec2_selftest.py
-
curl -L -o _sec2_selftest.py https://huggingface.co/spaces/a3216/xtc-backend/resolve/main/_sec2_selftest.py
18.4 kB
| """第二轮安全修复的回归自测(V7 / V9 / auth)。 | |
| 覆盖: | |
| - V7 注销账号改软删除:文件/备份(内容 + meta)搬到 trash/<ts>/… 再删原件, | |
| 原命名空间清空,审计里带 trash_moved / trash_failed / trash_prefix | |
| - V7 大宗删除护栏:待处理条目 > 200 时 409 bulk_delete_refused,?force=1 才继续 | |
| - V7 purge_trash():早于阈值的整个时间戳批次被删掉,未过期批次保留 | |
| - V9 XTC_ADMIN_READONLY=1:POST /admin/api/providers → 403 admin_readonly, | |
| GET /admin/api/providers 仍 200,白名单端点(xtc-access-token)仍可 POST | |
| - auth 未配置 XTC_ACCESS_KEY 时:XTC_DEV_MODE=0 → /v1/models 503 | |
| server_misconfigured;XTC_DEV_MODE=1 → 放行;`basic ` 伪支持已删除 | |
| 运行:python -X utf8 _sec2_selftest.py | |
| 全程不联网:Hub 未配置(HF_TOKEN/HF_CONFIG_REPO 清空),本地缓存目录指到临时目录, | |
| Hub 语义由本地缓存层等价承担(list_hub_keys 恒空 + list_local_keys 兜底)。 | |
| """ | |
| from __future__ import annotations | |
| import base64 | |
| import json | |
| import os | |
| import pathlib | |
| import sys | |
| import tempfile | |
| import types | |
| _TMP = tempfile.mkdtemp(prefix="xtc_sec2_") | |
| _BUCKET = pathlib.Path(_TMP) / "bucket" | |
| os.environ["XTC_DB_PATH"] = os.path.join(_TMP, "xtc.db") | |
| os.environ["XTC_BUCKET_DIR"] = os.path.join(_TMP, "bucket") | |
| # 本轮要测"没配 access_key"的两条分支,所以默认 dev mode 必须是关的 | |
| os.environ["XTC_DEV_MODE"] = "0" | |
| os.environ["XTC_ACCESS_KEY"] = "" | |
| os.environ["XTC_JWT_SECRET"] = "sec2-selftest-secret-0123456789abcdef" | |
| os.environ["XTC_ADMIN_KEY"] = "sec2-selftest-admin-key-0123456789" | |
| os.environ["XTC_ADMIN_READONLY"] = "0" | |
| for _k in ("HF_TOKEN", "HF_CONFIG_REPO", "XTC_HF_TOKEN", "XTC_HF_CONFIG_REPO"): | |
| os.environ.pop(_k, None) | |
| # 本地缓存写到临时目录,别污染盘根 | |
| from app import hf_storage # noqa: E402 | |
| hf_storage._local_root = lambda: _BUCKET # type: ignore[assignment] | |
| _BUCKET.mkdir(parents=True, exist_ok=True) | |
| from fastapi.testclient import TestClient # noqa: E402 | |
| from app import auth as auth_mod # noqa: E402 | |
| from app.config import get_settings # noqa: E402 | |
| from app.database import get_conn, init_db # noqa: E402 | |
| from app.main import app # noqa: E402 | |
| from app.services import admin_guard, usage_store, user_files_store # noqa: E402 | |
| FAILS: list[str] = [] | |
| ADMIN_HDR = {"x-xtc-admin-key": os.environ["XTC_ADMIN_KEY"]} | |
| def check(name: str, cond: bool, extra: str = "") -> None: | |
| if cond: | |
| print(f" [PASS] {name}") | |
| else: | |
| print(f" [FAIL] {name} {extra}") | |
| FAILS.append(name) | |
| class _SettingsProxy: | |
| """把真实 settings 包一层,只覆盖测试关心的字段。""" | |
| def __init__(self, real, **over): | |
| self._real = real | |
| self._over = over | |
| def __getattr__(self, item): | |
| if item in self._over: | |
| return self._over[item] | |
| return getattr(self._real, item) | |
| def register(client: TestClient, username: str, password: str = "Passw0rd!"): | |
| return client.post("/u/api/register", json={"username": username, "password": password}) | |
| class _StubRequest: | |
| """最小 Request 桩:只提供闸门需要的 method / url.path。""" | |
| def __init__(self, method: str, path: str): | |
| self.method = method | |
| self.url = types.SimpleNamespace(path=path) | |
| def del_account(client: TestClient, url: str, headers: dict, password: str = "Passw0rd!"): | |
| """DELETE 带 body:httpx 的 .delete() 不接受 json=,统一用 request()。""" | |
| return client.request("DELETE", url, headers=headers, json={"password": password}) | |
| def ns_files(ns: str) -> list[str]: | |
| """本地缓存里某命名空间下的全部 key(Hub 未配置时的等价视图)。""" | |
| p = _BUCKET.joinpath(*[x for x in ns.split("/") if x]) | |
| if not p.exists(): | |
| return [] | |
| return sorted(f.relative_to(p).as_posix() for f in p.rglob("*") if f.is_file()) | |
| def latest_audit(action: str, target: str | None = None): | |
| for row in usage_store.list_audit(action=action, hours=1, limit=200): | |
| if target is None or str(row.get("target")) == str(target): | |
| return row | |
| return None | |
| def main() -> int: | |
| init_db() | |
| with get_conn() as conn: | |
| for t in ("file_meta", "user_accounts", "user_tokens", "audit_log"): | |
| conn.execute(f"DELETE FROM {t}") | |
| client = TestClient(app) | |
| # ===================================================================== | |
| print("\n[1] V7 软删除:3 个文件 + 2 个备份 → 搬进 trash/ 再删原件") | |
| ra = register(client, "erin") | |
| check("erin 注册成功", ra.status_code == 200, str(ra.text[:200])) | |
| uid = str(ra.json()["user"]["id"]) | |
| tok = ra.json()["token"] | |
| hdr = {"Authorization": f"Bearer {tok}"} | |
| file_keys: list[str] = [] | |
| for i in range(3): | |
| r = client.post( | |
| "/u/api/upload", | |
| headers=hdr, | |
| files={"file": (f"doc{i}.txt", f"erin-content-{i}".encode(), "text/plain")}, | |
| ) | |
| if r.status_code == 200: | |
| file_keys.append(r.json()["key"]) | |
| check("3 个文件上传成功", len(file_keys) == 3, str(len(file_keys))) | |
| backup_keys: list[str] = [] | |
| for i in range(2): | |
| bkey = f"{i:02d}" + "cd" * 15 # 定长 key,纯本地不联网 | |
| body = json.dumps({"config": {"accessKey": f"sk-{i}"}}).encode("utf-8") | |
| user_files_store.upload_user_backup_content(uid, bkey, body) | |
| user_files_store.backup_backup_meta( | |
| uid, | |
| bkey, | |
| { | |
| "key": bkey, | |
| "filename": f"backup{i}.json", | |
| "alias": f"backup{i}", | |
| "mime": "application/json", | |
| "size": len(body), | |
| "sha256": "00" * 32, | |
| "uploaded_at": 1, | |
| "uploaded_by": uid, | |
| }, | |
| ) | |
| backup_keys.append(bkey) | |
| check( | |
| "2 个备份内容就位", | |
| len(ns_files(f"user_backups/{uid}")) == 2, | |
| str(ns_files(f"user_backups/{uid}")), | |
| ) | |
| pending = user_files_store.count_all_user_objects(uid) | |
| check("注销前统计 = 5 条", pending == 5, f"pending={pending}") | |
| rd = del_account(client, "/u/api/account", hdr) | |
| check("注销 200", rd.status_code == 200, str(rd.text[:300])) | |
| trash = (rd.json() or {}).get("trash") or {} | |
| check("响应 trash.moved == 5", trash.get("moved") == 5, str(trash)) | |
| check("响应 trash.failed == 0", trash.get("failed") == 0, str(trash)) | |
| for ns in ( | |
| f"user_files/{uid}", | |
| f"user_files_meta/{uid}", | |
| f"user_backups/{uid}", | |
| f"user_backups_meta/{uid}", | |
| ): | |
| left = ns_files(ns) | |
| check(f"原命名空间已空:{ns}", left == [], str(left[:5])) | |
| tprefix = str(trash.get("trash_prefix") or "") | |
| check( | |
| "trash_prefix 形如 trash/<ts>/", | |
| tprefix.startswith("trash/") and tprefix.count("/") == 2, | |
| tprefix, | |
| ) | |
| ts_dir = tprefix.strip("/").split("/")[-1] if tprefix else "" | |
| content_trash = ns_files(f"trash/{ts_dir}/user_files/{uid}") + ns_files( | |
| f"trash/{ts_dir}/user_backups/{uid}" | |
| ) | |
| meta_trash = ns_files(f"trash/{ts_dir}/user_files_meta/{uid}") + ns_files( | |
| f"trash/{ts_dir}/user_backups_meta/{uid}" | |
| ) | |
| check("trash/<ts>/ 下内容对象 = 5", len(content_trash) == 5, str(content_trash)) | |
| check("trash/<ts>/ 下 meta 对象 = 5", len(meta_trash) == 5, str(len(meta_trash))) | |
| check( | |
| "trash/<ts>/ 下对象合计 = 10", | |
| len(content_trash) + len(meta_trash) == 10, | |
| str(len(content_trash) + len(meta_trash)), | |
| ) | |
| deleted_audit = latest_audit("user.account.deleted", uid) | |
| detail = (deleted_audit or {}).get("detail") or {} | |
| if isinstance(detail, str): | |
| detail = {"raw": detail} | |
| check("审计已记录 user.account.deleted", bool(deleted_audit), str(deleted_audit)[:200]) | |
| check("审计 trash_moved == 5", detail.get("trash_moved") == 5, str(detail)[:300]) | |
| check("审计 trash_failed == 0", detail.get("trash_failed") == 0, str(detail)[:300]) | |
| check( | |
| "审计 trash_prefix 正确", | |
| str(detail.get("trash_prefix") or "") == tprefix, | |
| f"{detail.get('trash_prefix')} vs {tprefix}", | |
| ) | |
| check( | |
| "审计摘要有 trash_moved:5", | |
| "trash_moved:5" in str(detail.get("trash_summary") or ""), | |
| str(detail.get("trash_summary")), | |
| ) | |
| with get_conn() as conn: | |
| left_rows = conn.execute( | |
| "SELECT COUNT(*) AS c FROM file_meta WHERE uploaded_by = ?", (uid,) | |
| ).fetchone()["c"] | |
| acc = conn.execute( | |
| "SELECT COUNT(*) AS c FROM user_accounts WHERE id = ?", (int(uid),) | |
| ).fetchone()["c"] | |
| check("file_meta 行已清空", int(left_rows) == 0, str(left_rows)) | |
| check("user_accounts 行已删除", int(acc) == 0, str(acc)) | |
| # ===================================================================== | |
| print("\n[2] V7 大宗护栏:201 条 meta → 409 bulk_delete_refused,?force=1 后成功") | |
| rb = register(client, "frank") | |
| check("frank 注册成功", rb.status_code == 200, str(rb.text[:200])) | |
| uid_b = str(rb.json()["user"]["id"]) | |
| hdr_b = {"Authorization": f"Bearer {rb.json()['token']}"} | |
| for i in range(201): | |
| key = f"{i:064x}" | |
| user_files_store.backup_file_meta( | |
| uid_b, key, {"key": key, "alias": f"f{i}", "size": 1, "uploaded_at": 1} | |
| ) | |
| pending_b = user_files_store.count_all_user_objects(uid_b) | |
| check("待处理条目 = 201", pending_b == 201, f"pending={pending_b}") | |
| guarded = del_account(client, "/u/api/account", hdr_b) | |
| check("无 force 时 409", guarded.status_code == 409, str(guarded.status_code)) | |
| err = (guarded.json() or {}).get("error") or {} | |
| check("错误码 bulk_delete_refused", err.get("code") == "bulk_delete_refused", str(err)[:300]) | |
| gdetails = err.get("details") or {} | |
| check( | |
| "错误详情带 pending/limit", | |
| gdetails.get("pending") == 201 and gdetails.get("limit") == 200, | |
| str(gdetails), | |
| ) | |
| check( | |
| "被拒后数据未动", | |
| len(ns_files(f"user_files_meta/{uid_b}")) == 201, | |
| str(len(ns_files(f"user_files_meta/{uid_b}"))), | |
| ) | |
| rej_audit = latest_audit("user.account.bulk_delete_refused", uid_b) | |
| check("被拒已有审计", bool(rej_audit), str(rej_audit)[:200]) | |
| forced = del_account(client, "/u/api/account?force=1", hdr_b) | |
| check("带 force=1 后 200", forced.status_code == 200, str(forced.text[:300])) | |
| check( | |
| "force 后 trash.moved == 201", | |
| ((forced.json() or {}).get("trash") or {}).get("moved") == 201, | |
| str((forced.json() or {}).get("trash")), | |
| ) | |
| check( | |
| "force 后原命名空间已空", | |
| ns_files(f"user_files_meta/{uid_b}") == [], | |
| str(ns_files(f"user_files_meta/{uid_b}")[:5]), | |
| ) | |
| # ===================================================================== | |
| print("\n[3] V7 purge_trash:过期批次整批删除,未过期批次保留") | |
| old_ts = "19990101T000000Z" | |
| for i in range(3): | |
| hf_storage.upload_bytes(f"trash/{old_ts}/user_files/999", f"old{i}", b"x") | |
| fresh_ts = "29990101T000000Z" | |
| hf_storage.upload_bytes(f"trash/{fresh_ts}/user_files/999", "new0", b"y") | |
| purged = user_files_store.purge_trash(older_than_days=30) | |
| check("purge 返回删除条数 = 3", purged == 3, f"purged={purged}") | |
| check("过期批次已清空", ns_files(f"trash/{old_ts}") == [], str(ns_files(f"trash/{old_ts}"))) | |
| check( | |
| "未过期批次保留", | |
| ns_files(f"trash/{fresh_ts}/user_files/999") == ["new0"], | |
| str(ns_files(f"trash/{fresh_ts}/user_files/999")), | |
| ) | |
| check( | |
| "本轮注销产生的回收站批次未被误删", | |
| len(ns_files(f"trash/{ts_dir}/user_files/{uid}")) == 3, | |
| str(ns_files(f"trash/{ts_dir}/user_files/{uid}")), | |
| ) | |
| # ===================================================================== | |
| print("\n[4] V9 admin 只读模式(XTC_ADMIN_READONLY=1)") | |
| real = get_settings() | |
| orig_guard_settings = admin_guard.get_settings | |
| admin_guard.get_settings = lambda: _SettingsProxy( # type: ignore[assignment] | |
| real, admin_readonly=True | |
| ) | |
| body = { | |
| "id": "ro-test", | |
| "name": "ro-test", | |
| "type": "openai", | |
| "base_url": "https://api.example.com", | |
| "api_keys": ["sk-not-real"], | |
| } | |
| blocked = client.post("/admin/api/providers", headers=ADMIN_HDR, json=body) | |
| check("POST /admin/api/providers → 403", blocked.status_code == 403, str(blocked.status_code)) | |
| berr = (blocked.json() or {}).get("error") or {} | |
| check("错误码 admin_readonly", berr.get("code") == "admin_readonly", str(berr)[:300]) | |
| ro_audit = latest_audit("admin.readonly_blocked") | |
| check("只读拦截已审计", bool(ro_audit), str(ro_audit)[:200]) | |
| allowed_read = client.get("/admin/api/providers", headers=ADMIN_HDR) | |
| check( | |
| "GET /admin/api/providers 仍 200", | |
| allowed_read.status_code == 200, | |
| str(allowed_read.status_code), | |
| ) | |
| check( | |
| "GET 返回 providers 字段", | |
| "providers" in (allowed_read.json() or {}), | |
| str(allowed_read.text[:200]), | |
| ) | |
| tok_r = client.post("/admin/api/xtc-access-token", headers=ADMIN_HDR, json={}) | |
| check( | |
| "白名单 POST /admin/api/xtc-access-token 不被拦", | |
| tok_r.status_code == 200, | |
| f"{tok_r.status_code} {tok_r.text[:200]}", | |
| ) | |
| blocked_del = client.request("DELETE", "/admin/api/providers?id=ro-test", headers=ADMIN_HDR) | |
| derr = (blocked_del.json() or {}).get("error") or {} | |
| check( | |
| "DELETE /admin/api/providers 也是 403 admin_readonly", | |
| blocked_del.status_code == 403 and derr.get("code") == "admin_readonly", | |
| f"{blocked_del.status_code} {blocked_del.text[:200]}", | |
| ) | |
| admin_guard.get_settings = orig_guard_settings # type: ignore[assignment] | |
| # 只读关闭后同一个写方法不再被闸门拦下:这里刻意不带 admin key, | |
| # 期望回落到鉴权失败 401(而不是 403 admin_readonly),也不留下任何配置。 | |
| reopened = client.post("/admin/api/providers", json=body) | |
| rerr = (reopened.json() or {}).get("error") or {} | |
| check( | |
| "只读关闭后写方法不再返回 admin_readonly(回落 401)", | |
| reopened.status_code == 401 and rerr.get("code") != "admin_readonly", | |
| f"{reopened.status_code} {reopened.text[:200]}", | |
| ) | |
| # ===================================================================== | |
| print("\n[4b] V9 闸门边界:路径变形 / 子路径 / 读方法(直接调闸门函数)") | |
| from app.errors import HttpError # noqa: E402 | |
| admin_guard.get_settings = lambda: _SettingsProxy( # type: ignore[assignment] | |
| real, admin_readonly=True | |
| ) | |
| def gate(method: str, path: str) -> str: | |
| """返回 'blocked' / 'allowed'。""" | |
| try: | |
| admin_guard.check_admin_readonly(_StubRequest(method, path)) | |
| return "allowed" | |
| except HttpError as e: | |
| return "blocked:" + str(e.code) | |
| check("POST //admin/api//providers 也拦(路径折叠)", | |
| gate("POST", "//admin/api//providers") == "blocked:admin_readonly", | |
| gate("POST", "//admin/api//providers")) | |
| check("POST /admin/api/login 放行(白名单)", | |
| gate("POST", "/admin/api/login") == "allowed", gate("POST", "/admin/api/login")) | |
| check("POST /admin/api/login-any 不放行(不许前缀越界)", | |
| gate("POST", "/admin/api/login-any") == "blocked:admin_readonly", | |
| gate("POST", "/admin/api/login-any")) | |
| check("POST /v1/chat/completions 不受影响(非 admin 路径)", | |
| gate("POST", "/v1/chat/completions") == "allowed", gate("POST", "/v1/chat/completions")) | |
| check("GET /admin/api/providers 放行", gate("GET", "/admin/api/providers") == "allowed", | |
| gate("GET", "/admin/api/providers")) | |
| check("OPTIONS /admin/api/providers 放行(CORS 预检)", | |
| gate("OPTIONS", "/admin/api/providers") == "allowed", | |
| gate("OPTIONS", "/admin/api/providers")) | |
| admin_guard.get_settings = orig_guard_settings # type: ignore[assignment] | |
| # ===================================================================== | |
| print("\n[5] auth:未配置 access_key 时 dev-mode 必须是显式开关") | |
| orig_auth_settings = auth_mod.get_settings | |
| auth_mod.get_settings = lambda: _SettingsProxy( # type: ignore[assignment] | |
| real, has_access_key=False, xtc_dev_mode=False | |
| ) | |
| r503 = client.get("/v1/models") | |
| check("DEV_MODE=0 → 503", r503.status_code == 503, str(r503.status_code)) | |
| e503 = (r503.json() or {}).get("error") or {} | |
| check("错误码 server_misconfigured", e503.get("code") == "server_misconfigured", str(e503)[:300]) | |
| auth_mod.get_settings = lambda: _SettingsProxy( # type: ignore[assignment] | |
| real, has_access_key=False, xtc_dev_mode=True | |
| ) | |
| rdev = client.get("/v1/models") | |
| check( | |
| "DEV_MODE=1 → 放行(200)", | |
| rdev.status_code == 200, | |
| f"{rdev.status_code} {rdev.text[:200]}", | |
| ) | |
| print("\n[5b] auth:`basic ` 伪支持已删除,Bearer / header 正常") | |
| KEY = "sec2-real-key-0123456789abcdef" | |
| auth_mod.get_settings = lambda: _SettingsProxy( # type: ignore[assignment] | |
| real, has_access_key=True, xtc_access_key=KEY | |
| ) | |
| no_hdr = client.get("/v1/models") | |
| check("无 key → 401", no_hdr.status_code == 401, str(no_hdr.status_code)) | |
| ok_hdr = client.get("/v1/models", headers={"x-xtc-access-key": KEY}) | |
| check("正确 x-xtc-access-key → 200", ok_hdr.status_code == 200, str(ok_hdr.status_code)) | |
| ok_bearer = client.get("/v1/models", headers={"Authorization": f"Bearer {KEY}"}) | |
| check("正确 Bearer → 200", ok_bearer.status_code == 200, str(ok_bearer.status_code)) | |
| b64 = base64.b64encode(f"user:{KEY}".encode()).decode() | |
| ok_basic = client.get("/v1/models", headers={"Authorization": f"Basic {b64}"}) | |
| check("Basic 不再被当作 key(401)", ok_basic.status_code == 401, str(ok_basic.status_code)) | |
| auth_mod.get_settings = orig_auth_settings # type: ignore[assignment] | |
| print("\n" + "=" * 60) | |
| if FAILS: | |
| print(f"FAILED: {len(FAILS)} 项 -> {FAILS}") | |
| return 1 | |
| print("ALL PASS") | |
| return 0 | |
| if __name__ == "__main__": | |
| sys.exit(main()) | |