Files
ecs-relay-service/patch-source/0de3db40fc2044b0/hainuo-relay/tests/test_integration.py
T

144 lines
7.5 KiB
Python

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 == []