Import ECS deployed relay source and historical patches (2026-10-27)

This commit is contained in:
ex_tianzy
2026-10-27 17:26:58 +08:00
commit 011a7797ee
319 changed files with 34265 additions and 0 deletions
@@ -0,0 +1,141 @@
import asyncio
import hashlib
import json
import secrets
import time
import pytest
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from websockets.asyncio.client import connect
from relay.crypto import load_private, sign
from relay.device import DeviceJournal
from relay.config import Settings
from .conftest import provision, connect_device
from .test_integration import dispatch, event
async def test_expired_and_capacity_oauth(env):
client = env["client"]
data = (await client.post("/oauth/start", json={})).json()
env["connector"].state.oauth.pending[data["state"]].expires = time.monotonic() - 1
assert (await client.get("/oauth/cb", params={"state": data["state"], "code": "x"})).status_code == 400
env["settings"].max_pending = 1
assert (await client.post("/oauth/start", json={})).status_code == 201
assert (await client.post("/oauth/start", json={})).status_code == 503
async def test_binding_wrong_signature_does_not_consume(env):
# Provision one device but remove initial binding to exercise a second code.
directory, host = await provision(env)
env["connector"].state.store.unbind("ou_test")
response = await env["client"].post("/admin/test/binding-code", headers=env["admin"],
json={"open_id": "ou_test", "text": "ignored"})
code = response.json()["message"].split(":")[-1]
proof = sign({"host_id": host, "code": code, "ts": int(time.time())}, load_private(directory / "device.key"))
damaged = {**proof, "signature": "AAAA"}
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": damaged})).status_code == 403
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": proof})).status_code == 200
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": proof})).status_code == 404
async def test_timeout_is_unknown_and_cannot_reexecute(env):
directory, host = await provision(env)
# A live session is required: pause reply processing to reproduce an ambiguous result.
await connect_device(env, directory)
env["connector"].state.reply_task.cancel()
await asyncio.sleep(0)
result = await dispatch(env, "ou_test", "/回显 delayed", "timeout-turn")
assert result.json()["status"] == "unknown"
assert (await dispatch(env, "ou_test", "/回显 retried", "timeout-turn")).json()["status"] == "duplicate"
assert (await env["client"].get("/ready")).status_code == 503
async def test_duplicate_device_connection_rejected(env):
from relay.crypto import raw_public
from cryptography.hazmat.primitives.asymmetric import x25519
directory, host = await provision(env)
await connect_device(env, directory)
async with connect(env["router_url"], proxy=None) as ws:
challenge = json.loads(await ws.recv())["challenge"]
proof = sign({"host_id": host, "session_id": secrets.token_hex(16), "challenge": challenge,
"kx": raw_public(x25519.X25519PrivateKey.generate().public_key()), "ts": int(time.time())},
load_private(directory / "device.key"))
await ws.send(json.dumps({"host_id": host, "cert": (directory / "device.pem").read_text(), "proof": proof}))
from websockets.exceptions import ConnectionClosed
with pytest.raises(ConnectionClosed):
await ws.recv()
assert (await dispatch(env, "ou_test", "/回显 original")).json()["result"] == "original"
async def test_encrypted_webhook_and_stale_signature(env):
directory, _ = await provision(env)
await connect_device(env, directory)
s = env["settings"]
raw_event = json.dumps(event(env, "om_encrypted"), ensure_ascii=False).encode()
pad = padding.PKCS7(128).padder()
padded = pad.update(raw_event) + pad.finalize()
iv = secrets.token_bytes(16)
enc = Cipher(algorithms.AES(hashlib.sha256(s.feishu_encrypt_key.encode()).digest()), modes.CBC(iv)).encryptor()
import base64
raw = json.dumps({"encrypt": base64.b64encode(iv + enc.update(padded) + enc.finalize()).decode()}).encode()
timestamp, nonce = str(int(time.time())), "encrypted-nonce"
headers = {"X-Lark-Request-Timestamp": timestamp, "X-Lark-Request-Nonce": nonce,
"X-Lark-Signature": hashlib.sha256((timestamp + nonce + s.feishu_encrypt_key).encode() + raw).hexdigest()}
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.01)
assert env["platform"].replies == [("om_encrypted", "平台事件")]
headers["X-Lark-Request-Timestamp"] = str(int(time.time()) - 600)
assert (await env["client"].post("/feishu/event", content=raw, headers=headers)).status_code == 403
async def test_h5_and_whoami_only_returns_owned_static_domain(env):
await provision(env)
env["settings"].device_domain = "pc.example.invalid"
response = await env["client"].get("/h5")
assert response.status_code == 200
assert "script-src 'self'" in response.headers["content-security-policy"]
assert (await env["client"].get("/assets/app.js")).status_code == 200
assert (await env["client"].get("/api/whoami")).status_code == 401
response = await env["client"].get("/api/whoami?target=https://evil.invalid", headers={"Authorization": "Bearer fake-user"})
assert response.status_code == 200
assert response.json()["url"].endswith(".pc.example.invalid/")
assert response.json()["device_login_required"] is True
async def test_proxy_blocks_auth_endpoints_absolute_urls_and_traversal(env):
env["settings"].proxy_enabled = True
for target in ["https://evil.invalid/", "//evil.invalid/", "/open-apis/auth/v3/tenant_access_token/internal",
"/open-apis/authen/v1/user_info", "/open-apis/drive/v1/files/%2e%2e/auth", "/open-apis/drive/v1/files%0d%0aX:evil"]:
result = await env["client"].get("/proxy", headers={"Authorization": "Bearer fake-user", "X-Relay-Target": target})
assert result.status_code == 403, target
def test_device_journal_survives_restart(tmp_path):
path = tmp_path / "journal.sqlite"
journal = DeviceJournal(path)
assert journal.consume("turn")
journal.close()
journal = DeviceJournal(path)
assert not journal.consume("turn")
journal.close()
def test_production_fails_closed():
with pytest.raises(ValueError):
Settings(environment="production", admin_secret="short", internal_secret="short")
with pytest.raises(ValueError):
Settings(environment="production", admin_secret="a" * 40, internal_secret="b" * 40,
public_url="http://localhost")
async def test_validation_errors_do_not_echo_tokens(env):
token = "fake-confidential-token-" * 300
response = await env["client"].post("/oauth/refresh", json={"refresh_token": token})
assert response.status_code == 422
assert "fake-confidential" not in response.text
assert response.json() == {"detail": "invalid request parameters"}