import asyncio import hashlib import json import time import uuid from relay.crypto import load_private, sign from .conftest import provision, connect_device async def dispatch(env, owner, text, turn=None): return await env["client"].post("/admin/test/dispatch", headers=env["admin"], json={"open_id": owner, "text": text, "turn_id": turn or uuid.uuid4().hex}) async def test_two_devices_encrypted_isolation_and_dedup(env): a, ah = await provision(env, "ou_a") b, bh = await provision(env, "ou_b") await connect_device(env, a) await connect_device(env, b) responses = await asyncio.gather(dispatch(env, "ou_a", "/回显 A的唯一结果"), dispatch(env, "ou_b", "/回显 B的唯一结果")) assert [x.json()["result"] for x in responses] == ["A的唯一结果", "B的唯一结果"] first = await dispatch(env, "ou_a", "/回显 once", "same-turn") again = await dispatch(env, "ou_a", "/回显 twice", "same-turn") assert first.json()["status"] == "completed" assert again.json()["status"] == "duplicate" # Directory compromise cannot silently substitute B's certificate for A. presence_b = await env["redis"].get("hn:online:" + bh) await env["redis"].set("hn:online:" + ah, presence_b) assert (await dispatch(env, "ou_a", "/回显 leaked")).status_code == 409 async def test_offline_revoke_and_persistence(env): directory, host = await provision(env) assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "offline" await connect_device(env, directory) assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "completed" result = await env["client"].post(f"/admin/devices/{host}/revoke", headers=env["admin"]) assert result.status_code == 200 assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "unavailable" await asyncio.sleep(0.05) assert not await env["redis"].exists("hn:online:" + host) from relay.store import Store db = Store(env["settings"].data_dir / "metadata.sqlite") assert db.device(host)["revoked"] == 1 db.close() async def test_device_read_boundary(env): directory, host = await provision(env) root = env["root"] / "test-files" root.mkdir() (root / "allowed.txt").write_text("授权内容", encoding="utf-8") (env["root"] / "outside.txt").write_text("不该读到", encoding="utf-8") await connect_device(env, directory, root) assert (await dispatch(env, "ou_test", "/读取 allowed.txt")).json()["result"] == "授权内容" assert "拒绝" in (await dispatch(env, "ou_test", "/读取 ../outside.txt")).json()["result"] assert "只读诊断" in (await dispatch(env, "ou_test", "rm -rf /")).json()["result"] async def test_binding_requires_device_proof_and_one_time_code(env): directory, host = await provision(env) response = await env["client"].post("/device/bind", json={"host_id": host, "proof": {}}) assert response.status_code == 403 response = await env["client"].post("/admin/devices", json={"host_id": host, "cert": "invalid"}) assert response.status_code == 401 async def test_oauth_wrong_secret_does_not_destroy_and_claim_once(env): client = env["client"] start = await client.post("/oauth/start?state=attacker", json={}) assert start.status_code == 201 data = start.json() assert data["state"] != "attacker" assert data["claim_secret"] not in data["authorization_url"] cb = await client.get("/oauth/cb", params={"state": data["state"], "code": "fake-code"}) assert cb.status_code == 200 bad = await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": "bad"}) assert bad.status_code == 404 good = await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]}) assert good.status_code == 200 assert good.json()["expires_in"] == 6900 assert "code" not in good.json() assert good.headers["cache-control"] == "no-store" assert (await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]})).status_code == 404 assert (await client.get("/oauth/cb?state=unknown&code=x")).status_code == 400 async def test_oauth_concurrent_callbacks_claims_and_refresh(env): client = env["client"] data = (await client.post("/oauth/start", json={})).json() responses = await asyncio.gather(*[client.get("/oauth/cb", params={"state": data["state"], "code": "same"}) for _ in range(2)]) assert sorted(x.status_code for x in responses) == [200, 400] assert env["platform"].exchanges == 1 responses = await asyncio.gather(*[client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]}) for _ in range(2)]) assert sorted(x.status_code for x in responses) == [200, 404] responses = await asyncio.gather(*[client.post("/oauth/refresh", json={"refresh_token": "same-fake-refresh"}) for _ in range(2)]) assert sorted(x.status_code for x in responses) == [200, 409] assert env["platform"].refreshes == 1 async def test_body_limit_proxy_disabled_and_rate_limit(env): client = env["client"] assert (await client.post("/oauth/start", content=b"x" * 300000)).status_code == 413 assert (await client.get("/proxy", headers={"X-Relay-Target": "https://evil.invalid"})).status_code == 404 statuses = [(await client.post("/oauth/start", json={})).status_code for _ in range(21)] assert statuses[-1] == 429 def event(env, message_id="om_test", text="/回显 平台事件", chat_type="p2p"): return {"header": {"event_type": "im.message.receive_v1", "app_id": env["settings"].feishu_app_id, "token": env["settings"].feishu_verification_token}, "event": {"sender": {"sender_type": "user", "sender_id": {"open_id": "ou_test"}}, "message": {"message_id": message_id, "chat_type": chat_type, "message_type": "text", "content": json.dumps({"text": text}, ensure_ascii=False)}}} async def test_webhook_signature_event_routing_and_replay(env): directory, _ = await provision(env) await connect_device(env, directory) raw = json.dumps(event(env), ensure_ascii=False).encode() timestamp, nonce = str(int(time.time())), "nonce" signature = hashlib.sha256((timestamp + nonce + env["settings"].feishu_encrypt_key).encode() + raw).hexdigest() headers = {"X-Lark-Request-Timestamp": timestamp, "X-Lark-Request-Nonce": nonce, "X-Lark-Signature": signature} assert (await env["client"].post("/feishu/event", content=raw)).status_code == 403 for _ in range(2): assert (await env["client"].post("/feishu/event", content=raw, headers=headers)).status_code == 200 for _ in range(100): if env["platform"].replies: break await asyncio.sleep(0.02) assert env["platform"].replies == [("om_test", "平台事件")] # No transcript or credentials persisted in either connector metadata or device journal. for db in [env["settings"].data_dir / "metadata.sqlite", directory / "journal.sqlite"]: assert "平台事件".encode() not in db.read_bytes() async def test_group_events_ignored(env): result = await env["client"].post("/internal/events", json=event(env, chat_type="group"), headers={"X-Internal-Secret": env["settings"].internal_secret}) assert result.status_code == 200 await asyncio.sleep(0.05) assert env["platform"].replies == []