144 lines
7.5 KiB
Python
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 == []
|