@furongjun1999/dsh-memory 0.6.0 → 0.6.1

package/md_cg/test_srcindex.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""真源索引契约层守卫（P0）：通用层覆盖任意文件 / 细化层仅可读文本 / 伴随文本挂通用层 / 回读逐字节。
+
+判据姿态（P0 两次踩坑的产物，勿简化回「猜粒度」）：
+  · **不猜提取器粒度**：细化层单位数与 `docindex.extract` 条数**平权**（units == extract + 1），
+    H1 节合并、过短节并入等语义归提取器，本层只保证「它切几节我就几条」；
+  · **哈希单一实现**：行区间哈希委托 `codeindex.region_hash`（sha1 前 12 位）；本模块自写第二份
+    的行为已被 5b/5c 抓出并删除——两处算法会让漂移检测永远 hash_match=True；
+  · **伴随文本挂通用层**：媒体不进可读文本分支，挂错层等于废掉多模态语义通道（6b 抓出）。
+
+实验纪律：全程 `tempfile` 临时目录 + 合成件（含**假魔数**的合成二进制，绝不用真实媒体/私有数据）；
+不写任何库面、不碰在役库、不出网。运行：退出码 0 = 全绿。
+"""
+from __future__ import annotations
+
+import io
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import codeindex                 # noqa: E402
+from md_cg import docindex                  # noqa: E402
+from md_cg import srcindex as S             # noqa: E402
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ck(cid: str, ok: bool, detail: str = "") -> None:
+    global PASS, FAIL
+    if ok:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append("%s %s" % (cid, detail))
+    print("  %s %s%s" % ("OK  " if ok else "FAIL", cid, "" if ok else "  " + detail))
+
+
+def w(path: str, data) -> str:
+    if isinstance(data, bytes):
+        with open(path, "wb") as f:
+            f.write(data)
+    else:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(data)
+    return path
+
+
+DOC = "\n".join([
+    "# 合成文档标题", "", "这是一段引言。", "",
+    "## 小节一", "", "小节一的正文，足够长以通过提取器的最小长度判断。", "",
+    "## 小节二", "", "小节二的正文，同样足够长，并带一行说明。", "",
+    "## 小节三", "", "小节三的正文。",
+])
+CCG = "\n".join([
+    "# 功能名：合成样例", "# 生效条件：仅用于 P0 契约层守卫；合成件、非真实数据",
+    "## 小节一", "正文一",
+])
+
+
+def main() -> int:
+    tmp = tempfile.mkdtemp(prefix="p0_srcindex_")
+    try:
+        md = w(os.path.join(tmp, "说明.md"), DOC)
+        ccg = w(os.path.join(tmp, "带条件.md"), CCG)
+        png = w(os.path.join(tmp, "pic.png"), b"\x89PNG\r\n\x1a\n" + b"\x00\x01\x02" * 40)
+        w(os.path.join(tmp, "pic.md"), "# pic 简介\n\n这是伴随文本（sidecar）")
+        mp4 = w(os.path.join(tmp, "clip.mp4"), b"\x00\x00\x00\x18ftypmp42" + b"\x00" * 64)
+        raw = w(os.path.join(tmp, "blob.dat"), bytes(range(256)) * 4)
+        weird = w(os.path.join(tmp, "t.txt"), b"abc\x00def")            # NUL ⇒ 不可读
+        fake = w(os.path.join(tmp, "disguised.txt"), b"\x89PNG\r\n\x1a\n" + b"\x00" * 16)
+        empty = w(os.path.join(tmp, "empty.md"), "")
+
+        # ① 通用层：任意文件都有 ≥1 条 whole 单位（含空文件/不可读二进制）
+        for label, p in (("md", md), ("png", png), ("mp4", mp4), ("raw", raw),
+                         ("nul", weird), ("empty", empty)):
+            us = S.units(p)
+            ck("1a[%s] 通用层恒在" % label,
+               bool(us) and us[0]["span"]["unit"] == "whole" and bool(us[0]["span_hash"]),
+               "units=%d" % len(us))
+
+        # ② 细化层：与 docindex.extract 平权（不猜粒度）
+        for label, p in (("md", md), ("ccg", ccg)):
+            text = io.open(p, encoding="utf-8").read()
+            want = len(docindex.extract(text, path=p)) + 1
+            got = len(S.units(p))
+            ck("2a[%s] 单位数 == extract+1" % label, got == want, "units=%d want=%d" % (got, want))
+        ck("2b[png] 无细化层", all(u["span"]["unit"] == "whole" for u in S.units(png)))
+        ck("2c[NUL 文本] 判不可读、不细化",
+           all(u["span"]["unit"] == "whole" for u in S.units(weird)))
+        ck("2d[空文件] 不细化且不抛", len(S.units(empty)) == 1)
+
+        # ③ 类型判据：魔数优先于扩展名；未知类型不拒
+        ck("3a[魔数优先] .txt 内容为 PNG ⇒ image/png",
+           S.sniff_type(fake) == "image/png", S.sniff_type(fake))
+        ck("3b[扩展名兜底] .md ⇒ text/markdown", S.sniff_type(md) == "text/markdown")
+        ck("3c[未知不拒] .dat ⇒ octet-stream",
+           S.sniff_type(raw) == "application/octet-stream", S.sniff_type(raw))
+
+        # ④ 哈希判别力：改 1 字节 ⇒ file_hash 变；旧单位回读 hash_match=False
+        u0 = S.units(md)[0]
+        h0 = u0["src"]["file_hash"]
+        w(md, DOC.replace("这是一段引言。", "这是一段引言！"))
+        u1 = S.units(md)[0]
+        ck("4a[1 字节改判] file_hash 变", h0 != u1["src"]["file_hash"])
+        ck("4b[陈旧检出] 旧单位回读 hash_match=False",
+           S.read_unit(u0).get("hash_match") is False)
+        ck("4c[新鲜一致] 新单位回读 hash_match=True",
+           S.read_unit(u1).get("hash_match") is True)
+
+        # ⑤ 行区间回读逐字节 + 与 codeindex.region_hash 单一实现
+        lu = [u for u in S.units(md) if u["span"]["unit"] == "line"][0]
+        got = S.read_unit(lu)
+        lines = io.open(md, encoding="utf-8").read().split("\n")
+        want_text = "\n".join(lines[lu["span"]["start"] - 1:lu["span"]["end"]])
+        ck("5a[区间逐字节]", got.get("text") == want_text, repr(got.get("text"))[:60])
+        ck("5b[区间哈希一致]", got.get("hash_match") is True)
+        ck("5c[哈希单一实现] 委托 codeindex.region_hash",
+           codeindex.region_hash(lines, lu["span"]["start"], lu["span"]["end"])
+           == S.region_hash("\n".join(lines), lu["span"]["start"], lu["span"]["end"])
+           == got["hash"])
+
+        # ⑥ 伴随文本挂**通用层**（媒体条目的语义通道）
+        comps = S.companions(png)
+        u_png = S.units(png)[0]
+        ck("6a[sidecar 发现]", any(c["kind"] == "sidecar" for c in comps),
+           str([c["name"] for c in comps]))
+        ck("6b[挂进通用层] media 条目 text_view 含伴随文本且带 companions",
+           "伴随文本" in u_png["text_view"] and bool(u_png.get("companions")))
+
+        # ⑦ 未实现 locator 必须显式不静默
+        bad = S.read_unit({"src": {"path": md}, "span": {"unit": "time", "t0": 0, "t1": 1}})
+        ck("7a[time 显式不支持]", bad.get("ok") is False and "time" in bad.get("error", ""),
+           str(bad)[:80])
+
+        # ⑧ CCG 条件面进入细化层（且与该文件的 CCG 行相关）
+        ccg_units = S.units(ccg)
+        ck("8a[条件面非空]", any(u.get("condition_space") for u in ccg_units),
+           str([bool(u.get("condition_space")) for u in ccg_units]))
+        ck("8b[CCG 行落在细化层]",
+           any("生效条件" in (u.get("text_view") or "") or
+               "生效条件" in str(u.get("condition_space"))
+               for u in ccg_units if u["span"]["unit"] == "line"),
+           str([u.get("text_view") for u in ccg_units if u["span"]["unit"] == "line"])[:90])
+
+        # ⑨ 能力自陈与实现一致（契约漂移守卫）
+        cap = S.capability()
+        ck("9a[units 自陈]", tuple(cap["units"]) == S.UNITS == ("whole", "line"))
+        ck("9b[未实现项自陈]", set(cap["not_implemented"]) == {"time", "region", "byte"})
+        ck("9c[零依赖/不写状态]", cap["deps"] == [] and cap["writes_state"] is False)
+
+        # ⑩ 不存在路径：fail-closed 抛，而不是静默造条目
+        try:
+            S.units(os.path.join(tmp, "不存在.bin"))
+            ck("10a[不存在 fail-closed]", False, "未抛")
+        except OSError:
+            ck("10a[不存在 fail-closed]", True)
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n结果：PASS %d / FAIL %d" % (PASS, FAIL))
+    if FAILS:
+        print("失败项：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_tenant_env_override_warn.py

@@ -1,15 +1,17 @@
 # -*- coding: utf-8 -*-
-"""租户绑定 env 覆盖告警守卫（v8 N62 / v9 / 第15轮三次成立，止血验收）。
+"""租户绑定 env 覆盖守卫（v8 N62 止血告警 → 本轮 N62 第 5 轮 fail-closed）。
 
 攻击面：控制 MCP 进程 env 的部署面（宿主配置 / 启动器 / 同机多会话）——
 tenantA 签发的 designer(secret, can_admin) 令牌在 MDCG_TENANT=tenantB 下经
-mcp_server._build_principal → verify_token(tok, tenant=env) 静默以 tenantB
-身份运行（tenant=tenant or rec.get("tenant") 形参优先），全程零告警。
+mcp_server._build_principal → verify_token(tok, tenant=env) 以 tenantB 身份
+运行（tenant=tenant or rec.get("tenant") 形参优先）。
 
-止血口径（本轮）：仅加 stderr 告警，零闸变——冲突时 Principal 判定结果与
-修复前完全一致（形参/env 值仍优先），但必须开口。对照 MDCG_CLEARANCE 先例
-（mcp_server._build_principal 密级冲突告警）。clearance_cap 夹紧接线与租户
-绑定强校验不在本项范围（另行 deferred）。
+契约演进（N62 五轮留档）：
+  v8/v9/第15轮：仅 stderr 告警零闸变（止血口径——先开口，强校验 deferred）；
+  本轮（2026-09-27 第 5 次，medium 维持）：告警改 fail-closed 拒绝
+  （tokens.verify_token 抛 TokenError，消息含两侧租户与校正指引），并接线
+  登记租户 clearance_cap 夹紧（MDCG_TENANT_REGISTRY，与 mcp_server.
+  _resolve_root 同源；未登记租户零闸变）。
 
 运行：python -m md_cg.test_tenant_env_override_warn
 """
@@ -26,7 +28,7 @@ from . import tokens
 
 PASS = FAIL = 0
 FAILS = []
-MARK = "租户绑定被入参覆盖"          # 告警稳定锚点（tokens.verify_token）
+MARK = "租户绑定被入参覆盖"          # fail-closed 拒绝消息稳定锚点
 
 
 def check(name, cond, detail=""):
@@ -41,82 +43,89 @@ def check(name, cond, detail=""):
 
 
 def _verify_capture(token, tenant, path):
-    """verify_token 并捕获 stderr，返回 (principal, stderr_text)。"""
+    """verify_token 捕获异常与 stderr，返回 (principal|None, stderr_text, exc|None)。"""
     buf = io.StringIO()
-    with contextlib.redirect_stderr(buf):
-        p = tokens.verify_token(token, tenant=tenant, path=path)
-    return p, buf.getvalue()
+    p = exc = None
+    try:
+        with contextlib.redirect_stderr(buf):
+            p = tokens.verify_token(token, tenant=tenant, path=path)
+    except tokens.TokenError as e:
+        exc = e
+    return p, buf.getvalue(), exc
 
 
 def main():
     sys.stdout.reconfigure(encoding="utf-8", errors="replace")
     root = tempfile.mkdtemp(prefix="mdcg_tenant_warn_")
     tf = os.path.join(root, "_tokens.json")
+    # 登记表钉在临时不存在路径：守卫全程不触真实 ~/.mdcg/_tenants.json，
+    # 且「未登记 → 零夹紧」确定性（冲突拒绝发生在登记表访问之前）。
+    reg_path = os.path.join(root, "_tenants_absent.json")
+    old_reg = os.environ.get("MDCG_TENANT_REGISTRY")
+    os.environ["MDCG_TENANT_REGISTRY"] = reg_path
     try:
-        # ---------------- ① 攻击复现（单元级） ----------------
-        print("\n[1] 攻击复现：tenantA 令牌被 tenantB 形参覆盖必须告警")
+        # ---------------- ① 攻击复现（单元级，fail-closed） ----------------
+        print("\n[1] 攻击复现：tenantA 令牌被 tenantB 形参覆盖 → 拒绝")
         d = tokens.issue("designer", actor="dummy-designer", tenant="tenantA",
                          path=tf)
-        p, err = _verify_capture(d["token"], "tenantB", tf)
-        check("冲突覆盖发 stderr 告警", MARK in err,
-              (err.strip().splitlines() or ["（零 stderr 输出——静默覆盖成立）"])[-1][:90])
-        check("告警含两侧租户名", "tenantA" in err and "tenantB" in err,
-              err.strip()[:100])
-
-        # ---------------- ② 零闸变（止血不改判定） ----------------
-        print("\n[2] 零闸变（判停结果与修复前一致，只加告警）")
-        check("形参/env 租户仍优先生效", p.tenant == "tenantB",
-              f"principal.tenant={p.tenant}")
-        check("权限面不受影响（designer/can_admin 原样）",
-              p.role == "designer" and p.can_admin is True,
-              f"role={p.role} admin={p.can_admin}")
+        p, err, exc = _verify_capture(d["token"], "tenantB", tf)
+        check("冲突覆盖被拒（TokenError 且含锚点）",
+              p is None and exc is not None and MARK in str(exc),
+              f"p={p} exc={type(exc).__name__}: {str(exc)[:80]}")
+        check("拒绝消息含两侧租户与校正指引",
+              exc is not None and "tenantA" in str(exc) and "tenantB" in str(exc)
+              and "MDCG_TENANT" in str(exc), str(exc)[:100])
+
+        # ---------------- ② fail-closed（覆盖零放行） ----------------
+        print("\n[2] fail-closed（冲突路径零 Principal 放行）")
+        check("冲突路径不返回 Principal", p is None, f"p={p}")
 
         # ---------------- ③ 无冲突路径零误伤 ----------------
         print("\n[3] 无冲突路径零误伤")
-        p0, err0 = _verify_capture(d["token"], None, tf)
-        check("tenant=None：零告警且回退令牌租户",
-              MARK not in err0 and p0.tenant == "tenantA",
-              f"tenant={p0.tenant}")
-        p1, err1 = _verify_capture(d["token"], "", tf)
-        check("tenant=''（env 未设/空串）：零告警且回退令牌租户",
-              MARK not in err1 and p1.tenant == "tenantA",
-              f"tenant={p1.tenant}")
-        p2, err2 = _verify_capture(d["token"], "tenantA", tf)
-        check("tenant 同值：零告警", MARK not in err2 and p2.tenant == "tenantA",
-              f"tenant={p2.tenant}")
+        p0, err0, exc0 = _verify_capture(d["token"], None, tf)
+        check("tenant=None：零异常且回退令牌租户",
+              exc0 is None and MARK not in err0 and p0.tenant == "tenantA",
+              f"tenant={p0.tenant} err={exc0}")
+        p1, err1, exc1 = _verify_capture(d["token"], "", tf)
+        check("tenant=''（env 未设/空串）：零异常且回退令牌租户",
+              exc1 is None and MARK not in err1 and p1.tenant == "tenantA",
+              f"tenant={p1.tenant} err={exc1}")
+        p2, err2, exc2 = _verify_capture(d["token"], "tenantA", tf)
+        check("tenant 同值：零异常零告警",
+              exc2 is None and MARK not in err2 and p2.tenant == "tenantA",
+              f"tenant={p2.tenant} err={exc2}")
 
         # ---------------- ④ MCP 进程级入口（_build_principal 直调先例 b26） ----------------
         print("\n[4] MCP 进程级：MDCG_TOKEN(tenantA) + MDCG_TENANT=tenantB")
         from .mcp_server import _build_principal
         saved = {k: os.environ.get(k) for k in
                  ("MDCG_TOKEN", "MDCG_TENANT", "MDCG_TOKEN_FILE", "MDCG_ROOT",
-                  "MDCG_LEGACY_ENV_AUTH", "MDCG_CAN_ADMIN", "MDCG_CAN_WRITE",
+                  "MDCG_TENANT_REGISTRY", "MDCG_LEGACY_ENV_AUTH",
+                  "MDCG_LEGACY_ENV_ADMIN", "MDCG_CAN_ADMIN", "MDCG_CAN_WRITE",
                   "MDCG_CLEARANCE", "MDCG_ACTOR")}
         try:
             os.environ["MDCG_TOKEN"] = d["token"]
             os.environ["MDCG_TOKEN_FILE"] = tf
             os.environ["MDCG_ROOT"] = os.path.join(root, "mcp")
+            os.environ["MDCG_TENANT_REGISTRY"] = reg_path
             os.environ["MDCG_TENANT"] = "tenantB"
-            for k in ("MDCG_LEGACY_ENV_AUTH", "MDCG_CAN_ADMIN",
-                      "MDCG_CAN_WRITE", "MDCG_CLEARANCE", "MDCG_ACTOR"):
+            for k in ("MDCG_LEGACY_ENV_AUTH", "MDCG_LEGACY_ENV_ADMIN",
+                      "MDCG_CAN_ADMIN", "MDCG_CAN_WRITE", "MDCG_CLEARANCE",
+                      "MDCG_ACTOR"):
                 os.environ.pop(k, None)
             buf = io.StringIO()
             with contextlib.redirect_stderr(buf):
                 mp, merr = _build_principal()
             mout = buf.getvalue()
-            check("MCP 入口构建成功（攻击原样可达）", merr is None and mp is not None,
-                  f"err={merr}")
-            check("MCP 入口租户被覆盖为 tenantB（攻击面成立）",
-                  getattr(mp, "tenant", None) == "tenantB",
-                  f"tenant={getattr(mp, 'tenant', None)}")
-            check("MCP 入口 stderr 含覆盖告警", MARK in mout,
-                  (mout.strip().splitlines() or ["（零 stderr）"])[-1][:90])
-            # 无冲突对照：MDCG_TENANT 与令牌租户一致 → 零告警
+            check("MCP 入口覆盖被拒（err 含锚点，principal=None）",
+                  mp is None and merr is not None and MARK in merr,
+                  f"err={str(merr)[:90]}")
+            # 无冲突对照：MDCG_TENANT 与令牌租户一致 → 零异常正常通过
             os.environ["MDCG_TENANT"] = "tenantA"
             buf2 = io.StringIO()
             with contextlib.redirect_stderr(buf2):
                 mp2, merr2 = _build_principal()
-            check("MDCG_TENANT 同值：零告警",
+            check("MDCG_TENANT 同值：零异常零告警",
                   merr2 is None and MARK not in buf2.getvalue()
                   and getattr(mp2, "tenant", None) == "tenantA",
                   buf2.getvalue().strip()[:90])
@@ -127,6 +136,10 @@ def main():
                 else:
                     os.environ[k] = v
     finally:
+        if old_reg is None:
+            os.environ.pop("MDCG_TENANT_REGISTRY", None)
+        else:
+            os.environ["MDCG_TENANT_REGISTRY"] = old_reg
         shutil.rmtree(root, ignore_errors=True)
 
     print(f"\n通过 {PASS} / 失败 {FAIL}")