xtc-backend / _sec2_selftest.py
a3216's picture
feat(provider): 支持双钥匙上游(自定义请求头)—— Authorization 平台令牌 + X-WB2A-Key 应用密钥
09742fd
Raw History Blame Contribute Delete
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())