Import ECS deployed relay source and historical patches (2026-10-27)
This commit is contained in:
@@ -0,0 +1 @@
|
||||
"""Hainuo relay 0.1.0."""
|
||||
@@ -0,0 +1,216 @@
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import ssl
|
||||
import uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
from cryptography import x509
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric import ed25519
|
||||
from cryptography.x509.oid import NameOID
|
||||
|
||||
from .crypto import issue_ca, issue_device, load_private, pem_private
|
||||
|
||||
|
||||
def write_new(path, data, private=False):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
with path.open("xb") as f:
|
||||
f.write(data if isinstance(data, bytes) else data.encode())
|
||||
if private and os.name != "nt":
|
||||
path.chmod(0o600)
|
||||
|
||||
|
||||
def init_project(root: Path, hostname: str):
|
||||
if (root / ".env").exists():
|
||||
raise RuntimeError(".env exists; init never overwrites credentials")
|
||||
ca_key, ca = issue_ca()
|
||||
signer = ed25519.Ed25519PrivateKey.generate()
|
||||
write_new(root / "operator/ca.key", pem_private(ca_key), True)
|
||||
write_new(root / "runtime/trust/ca.pem", ca.public_bytes(serialization.Encoding.PEM))
|
||||
write_new(root / "runtime/connector/connector.key", pem_private(signer), True)
|
||||
write_new(root / "runtime/trust/connector.pub", signer.public_key().public_bytes(
|
||||
serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo))
|
||||
tls_key = ed25519.Ed25519PrivateKey.generate()
|
||||
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, hostname)])
|
||||
now = datetime.now(timezone.utc)
|
||||
tls = (x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(tls_key.public_key())
|
||||
.serial_number(x509.random_serial_number()).not_valid_before(now - timedelta(minutes=5))
|
||||
.not_valid_after(now + timedelta(days=30))
|
||||
.add_extension(x509.SubjectAlternativeName([x509.DNSName(hostname)]), critical=False)
|
||||
.sign(tls_key, algorithm=None))
|
||||
write_new(root / "runtime/tls/server.key", pem_private(tls_key), True)
|
||||
write_new(root / "runtime/tls/server.pem", tls.public_bytes(serialization.Encoding.PEM))
|
||||
redis_secret = secrets.token_hex(32)
|
||||
db_secret = secrets.token_hex(32)
|
||||
env = (f"HN_ENVIRONMENT=development\nHN_PUBLIC_HOST={hostname}\nHN_PUBLIC_URL=https://{hostname}\n"
|
||||
f"HN_ROUTER_URL=wss://{hostname}/device/ws\nHN_ADMIN_SECRET={secrets.token_hex(32)}\n"
|
||||
f"HN_INTERNAL_SECRET={secrets.token_hex(32)}\nHN_REDIS_PASSWORD={redis_secret}\n"
|
||||
f"HN_REDIS_URL=redis://:{redis_secret}@redis:6379/0\n"
|
||||
f"HN_POSTGRES_PASSWORD={db_secret}\nHN_DATABASE_URL=postgresql://hainuo:{db_secret}@postgres:5432/hainuo\n"
|
||||
"HN_FEISHU_ENABLED=false\nHN_FEISHU_API_BASE=https://open.feishu.cn\n"
|
||||
"HN_FEISHU_AUTHORIZE_URL=https://open.feishu.cn/open-apis/authen/v1/authorize\n"
|
||||
"HN_FEISHU_APP_ID=\nHN_FEISHU_APP_SECRET=\nHN_FEISHU_ENCRYPT_KEY=\n"
|
||||
"HN_FEISHU_VERIFICATION_TOKEN=\nHN_PROXY_ENABLED=false\nHN_DEVICE_DOMAIN=\n")
|
||||
write_new(root / ".env", env, True)
|
||||
print("已生成配置、连接器密钥、设备CA及临时TLS证书;未输出凭据。")
|
||||
print("operator/ca.key 仅保留在签发工作站,不要上传到ECS。临时TLS证书上线前须替换。")
|
||||
|
||||
|
||||
def device_request(directory):
|
||||
host = uuid.uuid4().hex
|
||||
private = ed25519.Ed25519PrivateKey.generate()
|
||||
write_new(directory / "device.key", pem_private(private), True)
|
||||
public = private.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo).decode()
|
||||
write_new(directory / "request.json", json.dumps({"host_id": host, "public_key": public}, indent=2))
|
||||
print("已在本机生成私钥和 request.json;仅将request.json交给签发工作站。")
|
||||
|
||||
|
||||
def issue(root, request_file, output):
|
||||
request = json.loads(request_file.read_text(encoding="utf-8"))
|
||||
host = request["host_id"]
|
||||
if len(host) != 32 or any(c not in "0123456789abcdef" for c in host):
|
||||
raise ValueError("invalid host identity")
|
||||
ca = x509.load_pem_x509_certificate((root / "runtime/trust/ca.pem").read_bytes())
|
||||
public = serialization.load_pem_public_key(request["public_key"].encode())
|
||||
if not isinstance(public, ed25519.Ed25519PublicKey):
|
||||
raise ValueError("Ed25519 required")
|
||||
cert = issue_device(load_private(root / "operator/ca.key"), ca, host, public)
|
||||
pem = cert.public_bytes(serialization.Encoding.PEM)
|
||||
write_new(output / "device.pem", pem)
|
||||
write_new(output / "ca.pem", (root / "runtime/trust/ca.pem").read_bytes())
|
||||
write_new(output / "connector.pub", (root / "runtime/trust/connector.pub").read_bytes())
|
||||
write_new(output / "device.json", json.dumps({"host_id": host, "owner": None}, indent=2))
|
||||
write_new(output / "registration.json", json.dumps({"host_id": host, "cert": pem.decode()}, indent=2))
|
||||
print("已签发设备证书;将device.pem、ca.pem、connector.pub、device.json交回原设备。")
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="海诺中继部署和设备工具")
|
||||
sub = parser.add_subparsers(dest="command", required=True)
|
||||
p = sub.add_parser("init")
|
||||
p.add_argument("--root", type=Path, default=Path("."))
|
||||
p.add_argument("--hostname", required=True)
|
||||
p = sub.add_parser("serve")
|
||||
p.add_argument("role", choices=["connector", "router"])
|
||||
p.add_argument("--host", default="127.0.0.1")
|
||||
p.add_argument("--port", type=int, default=8000)
|
||||
p = sub.add_parser("device-request")
|
||||
p.add_argument("--directory", type=Path, required=True)
|
||||
p = sub.add_parser("issue-device")
|
||||
p.add_argument("--root", type=Path, default=Path("."))
|
||||
p.add_argument("--request", type=Path, required=True)
|
||||
p.add_argument("--output", type=Path, required=True)
|
||||
p = sub.add_parser("register")
|
||||
p.add_argument("--registration", type=Path, required=True)
|
||||
p.add_argument("--url", required=True)
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
p = sub.add_parser("bind")
|
||||
p.add_argument("--directory", type=Path, required=True)
|
||||
p.add_argument("--url", required=True)
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
p = sub.add_parser("device")
|
||||
p.add_argument("--directory", type=Path, required=True)
|
||||
p.add_argument("--url", required=True)
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
p.add_argument("--test-root", type=Path)
|
||||
p.add_argument("--agent-url", help="Explicit loopback read-only Agent adapter endpoint")
|
||||
p.add_argument("--hainuo-config", type=Path, help="Native installer-1.065 API adapter config; alternative to --agent-url")
|
||||
p = sub.add_parser("hainuo-probe")
|
||||
p.add_argument("--config", type=Path, required=True)
|
||||
p = sub.add_parser("web-pair")
|
||||
p.add_argument("--directory", type=Path, required=True)
|
||||
p.add_argument("--url", required=True)
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
for command in ("status", "binding-code", "dispatch", "revoke", "unbind", "reconcile"):
|
||||
p = sub.add_parser(command)
|
||||
p.add_argument("--url", default="http://127.0.0.1:18081")
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
if command in {"binding-code", "dispatch"}:
|
||||
p.add_argument("--owner", required=True)
|
||||
if command == "dispatch":
|
||||
p.add_argument("--text", required=True)
|
||||
p.add_argument("--turn-id", default=None)
|
||||
if command in {"revoke", "unbind"}:
|
||||
p.add_argument("--host-id", required=True)
|
||||
args = parser.parse_args()
|
||||
if args.command == "init":
|
||||
init_project(args.root, args.hostname)
|
||||
elif args.command == "serve":
|
||||
import uvicorn
|
||||
uvicorn.run(f"relay.{args.role}:create_app", factory=True, host=args.host, port=args.port,
|
||||
workers=1, access_log=False, proxy_headers=False,
|
||||
ws_max_size=262144, ws_max_queue=16, log_level="warning")
|
||||
elif args.command == "device-request":
|
||||
device_request(args.directory)
|
||||
elif args.command == "issue-device":
|
||||
issue(args.root, args.request, args.output)
|
||||
elif args.command == "register":
|
||||
import getpass
|
||||
secret = os.environ.get("HN_ADMIN_SECRET") or getpass.getpass("Admin secret: ")
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else True
|
||||
with httpx.Client(verify=context, follow_redirects=False, timeout=15) as client:
|
||||
response = client.post(args.url.rstrip("/") + "/admin/devices",
|
||||
headers={"X-Admin-Secret": secret},
|
||||
json=json.loads(args.registration.read_text(encoding="utf-8")))
|
||||
if response.status_code != 201:
|
||||
raise RuntimeError(f"register failed: HTTP {response.status_code}")
|
||||
print("设备登记成功。")
|
||||
elif args.command == "bind":
|
||||
import getpass
|
||||
from .device import bind_device
|
||||
code = getpass.getpass("Binding code: ")
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else True
|
||||
asyncio.run(bind_device(args.directory, args.url, code, tls_verify=context))
|
||||
print("绑定成功。")
|
||||
elif args.command == "device":
|
||||
from .device import run_device
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else None
|
||||
asyncio.run(run_device(args.directory, args.url, root=args.test_root, ssl_context=context,
|
||||
agent_url=args.agent_url, hainuo_config=args.hainuo_config))
|
||||
elif args.command == "hainuo-probe":
|
||||
from .hainuo1065 import Hainuo1065Agent
|
||||
async def probe():
|
||||
adapter = Hainuo1065Agent(args.config)
|
||||
try:
|
||||
print(json.dumps(await adapter.probe(), ensure_ascii=False, indent=2))
|
||||
finally:
|
||||
await adapter.close()
|
||||
asyncio.run(probe())
|
||||
elif args.command == "web-pair":
|
||||
from .device import pair_browser
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else True
|
||||
result = asyncio.run(pair_browser(args.directory, args.url, tls_verify=context))
|
||||
print("网页地址:" + result["url"])
|
||||
print("一次性网页配对码(120秒有效):" + result["code"])
|
||||
else:
|
||||
import getpass
|
||||
secret = os.environ.get("HN_ADMIN_SECRET") or getpass.getpass("Admin secret: ")
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else True
|
||||
with httpx.Client(verify=context, timeout=200, follow_redirects=False) as client:
|
||||
paths = {"status": "/admin/devices", "binding-code": "/admin/test/binding-code",
|
||||
"dispatch": "/admin/test/dispatch", "reconcile": "/admin/reconcile"}
|
||||
if args.command in {"revoke", "unbind"}:
|
||||
if len(args.host_id) != 32 or any(c not in "0123456789abcdef" for c in args.host_id):
|
||||
raise ValueError("invalid host identity")
|
||||
path = f"/admin/devices/{args.host_id}/{args.command}"
|
||||
else:
|
||||
path = paths[args.command]
|
||||
body = None
|
||||
if args.command in {"binding-code", "dispatch"}:
|
||||
body = {"open_id": args.owner, "text": getattr(args, "text", "binding")}
|
||||
if getattr(args, "turn_id", None):
|
||||
body["turn_id"] = args.turn_id
|
||||
response = client.request("GET" if args.command == "status" else "POST", args.url.rstrip("/") + path,
|
||||
headers={"X-Admin-Secret": secret}, json=body)
|
||||
if response.status_code != 200:
|
||||
raise RuntimeError(f"operation failed: HTTP {response.status_code}")
|
||||
print(json.dumps(response.json(), ensure_ascii=False, indent=2))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,61 @@
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import time
|
||||
from fastapi import HTTPException, Request
|
||||
from starlette.responses import JSONResponse
|
||||
|
||||
|
||||
def require_secret(actual, expected):
|
||||
if not actual or not hmac.compare_digest(actual, expected):
|
||||
raise HTTPException(401, "unauthorized")
|
||||
|
||||
|
||||
async def rate_limit(redis, bucket: str, limit=60, seconds=60):
|
||||
# Atomic counter + expiry: a crash cannot leave a permanent bucket.
|
||||
key = "hn:rate:" + hashlib.sha256(bucket.encode()).hexdigest() + ":" + str(int(time.time()) // seconds)
|
||||
pipe = redis.pipeline(transaction=True)
|
||||
pipe.incr(key)
|
||||
pipe.expire(key, seconds * 2)
|
||||
result = (await pipe.execute())[0]
|
||||
if int(result) > limit:
|
||||
raise HTTPException(429, "rate limited", headers={"Retry-After": str(seconds)})
|
||||
|
||||
|
||||
class BodyLimitMiddleware:
|
||||
def __init__(self, app, max_body=262144):
|
||||
self.app, self.max_body = app, max_body
|
||||
|
||||
async def __call__(self, scope, receive, send):
|
||||
if scope["type"] != "http":
|
||||
return await self.app(scope, receive, send)
|
||||
messages, size = [], 0
|
||||
while True:
|
||||
message = await receive()
|
||||
if message["type"] == "http.disconnect":
|
||||
return
|
||||
size += len(message.get("body", b""))
|
||||
if size > self.max_body:
|
||||
return await JSONResponse({"detail": "body too large"}, status_code=413)(scope, receive, send)
|
||||
messages.append(message)
|
||||
if not message.get("more_body", False):
|
||||
break
|
||||
async def buffered():
|
||||
return messages.pop(0) if messages else await receive()
|
||||
await self.app(scope, buffered, send)
|
||||
|
||||
|
||||
def no_cache(response):
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
response.headers["X-Content-Type-Options"] = "nosniff"
|
||||
response.headers["Referrer-Policy"] = "no-referrer"
|
||||
return response
|
||||
|
||||
|
||||
async def json_pub(redis, channel, data):
|
||||
return await redis.publish(channel, json.dumps(data, separators=(",", ":")))
|
||||
|
||||
|
||||
def peer(request: Request):
|
||||
# Do not trust arbitrary X-Forwarded-For; configure uvicorn trusted proxies explicitly.
|
||||
return request.client.host if request.client else "unknown"
|
||||
@@ -0,0 +1,64 @@
|
||||
from pathlib import Path
|
||||
from pydantic import model_validator
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
|
||||
|
||||
class Settings(BaseSettings):
|
||||
model_config = SettingsConfigDict(env_prefix="HN_", extra="ignore", hide_input_in_errors=True)
|
||||
environment: str = "production"
|
||||
role: str = "connector"
|
||||
redis_url: str = "redis://127.0.0.1:6379/0"
|
||||
data_dir: Path = Path("runtime/connector")
|
||||
database_url: str = ""
|
||||
admin_secret: str = ""
|
||||
internal_secret: str = ""
|
||||
ca_cert: Path = Path("runtime/pki/ca.pem")
|
||||
connector_key: Path = Path("runtime/pki/connector.key")
|
||||
connector_public_key: Path = Path("runtime/pki/connector.pub")
|
||||
public_url: str = "https://relay.example.invalid"
|
||||
router_url: str = "wss://relay.example.invalid/device/ws"
|
||||
device_domain: str = ""
|
||||
feishu_api_base: str = "https://open.feishu.cn"
|
||||
feishu_authorize_url: str = "https://open.feishu.cn/open-apis/authen/v1/authorize"
|
||||
feishu_app_id: str = ""
|
||||
feishu_app_secret: str = ""
|
||||
feishu_encrypt_key: str = ""
|
||||
feishu_verification_token: str = ""
|
||||
feishu_enabled: bool = False
|
||||
oauth_enabled: bool = True
|
||||
feishu_event_source: str = "longconn"
|
||||
proxy_enabled: bool = False
|
||||
# A fixed allowlist, never a user supplied upstream URL.
|
||||
proxy_paths: str = "/open-apis/drive/v1/files,/open-apis/docx/v1/documents"
|
||||
request_timeout: int = 45
|
||||
max_body: int = 262144
|
||||
max_pending: int = 1000
|
||||
max_devices: int = 1000
|
||||
max_connections: int = 1000
|
||||
max_result: int = 16000
|
||||
allow_insecure_local: bool = False
|
||||
|
||||
@model_validator(mode="after")
|
||||
def validate_runtime(self):
|
||||
if self.environment not in {"production", "test", "development"}:
|
||||
raise ValueError("invalid environment")
|
||||
if self.role == "connector" and min(len(self.admin_secret), len(self.internal_secret)) < 32:
|
||||
raise ValueError("admin/internal secrets must each be at least 32 characters")
|
||||
if self.role == "longconn" and len(self.internal_secret) < 32:
|
||||
raise ValueError("internal credential must be at least 32 characters")
|
||||
if self.role == "connector" and self.admin_secret == self.internal_secret:
|
||||
raise ValueError("admin and internal credentials must be different")
|
||||
if self.environment == "production":
|
||||
if self.allow_insecure_local or not self.public_url.startswith("https://"):
|
||||
raise ValueError("production requires HTTPS")
|
||||
if not self.router_url.startswith("wss://"):
|
||||
raise ValueError("production requires WSS")
|
||||
if not self.feishu_api_base.startswith("https://"):
|
||||
raise ValueError("platform API requires HTTPS")
|
||||
if self.feishu_event_source not in {"longconn", "webhook"}:
|
||||
raise ValueError("invalid platform event source")
|
||||
if self.feishu_enabled and not all((self.feishu_app_id, self.feishu_app_secret)):
|
||||
raise ValueError("platform app ID and secret are required")
|
||||
if self.feishu_enabled and self.feishu_event_source == "webhook" and not all((self.feishu_encrypt_key, self.feishu_verification_token)):
|
||||
raise ValueError("webhook requires encryption key and verification token")
|
||||
return self
|
||||
@@ -0,0 +1,499 @@
|
||||
import asyncio
|
||||
import base64
|
||||
import contextlib
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import re
|
||||
import secrets
|
||||
import sqlite3
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import dataclass
|
||||
from urllib.parse import unquote, urlsplit
|
||||
|
||||
from cryptography.hazmat.primitives import hashes, padding
|
||||
from cryptography.hazmat.primitives.asymmetric import x25519
|
||||
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
|
||||
from fastapi import FastAPI, HTTPException, Request
|
||||
from fastapi.responses import HTMLResponse, JSONResponse
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from pydantic import BaseModel, Field
|
||||
from redis.asyncio import Redis
|
||||
|
||||
from .common import BodyLimitMiddleware, no_cache, peer, rate_limit, require_secret
|
||||
from .config import Settings
|
||||
from .crypto import (fingerprint, load_private, open_envelope, raw_public, seal,
|
||||
sign, verified, verify_device)
|
||||
from .oauth import OAuth
|
||||
from .platform import Feishu, PlatformError
|
||||
from .store import Store, INTEGRITY_ERRORS
|
||||
|
||||
|
||||
class Register(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
cert: str = Field(max_length=10000)
|
||||
|
||||
|
||||
class Bind(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
proof: dict
|
||||
|
||||
|
||||
class Instruction(BaseModel):
|
||||
open_id: str = Field(min_length=1, max_length=128)
|
||||
text: str = Field(min_length=1, max_length=8000)
|
||||
# Stable identity chosen by upstream, not generated again on retries.
|
||||
turn_id: str = Field(default_factory=lambda: uuid.uuid4().hex, pattern=r"^[A-Za-z0-9_-]{1,128}$")
|
||||
|
||||
|
||||
@dataclass
|
||||
class Pending:
|
||||
future: asyncio.Future
|
||||
private: object
|
||||
public: object
|
||||
host: str
|
||||
session: str
|
||||
|
||||
|
||||
class Broker:
|
||||
def __init__(self, settings, redis, store):
|
||||
self.s, self.r, self.store = settings, redis, store
|
||||
self.signer = load_private(settings.connector_key)
|
||||
self.pending: dict[str, Pending] = {}
|
||||
|
||||
async def replies(self, pub):
|
||||
async for message in pub.listen():
|
||||
if message["type"] != "message":
|
||||
continue
|
||||
try:
|
||||
data = json.loads(message["data"])
|
||||
item = self.pending.get(data["turn_id"])
|
||||
if not item or item.future.done():
|
||||
continue
|
||||
plain = open_envelope(data["envelope"], item.private, item.public,
|
||||
host_id=item.host, session_id=item.session)
|
||||
if plain["turn_id"] != data["turn_id"] or plain.get("type") != "result":
|
||||
continue
|
||||
result = plain.get("result", "")
|
||||
if not isinstance(result, str) or len(result) > self.s.max_result:
|
||||
continue
|
||||
item.future.set_result({"status": "completed", "turn_id": data["turn_id"], "result": result})
|
||||
except Exception:
|
||||
# Invalid packets never consume a pending result; do not log packet contents.
|
||||
continue
|
||||
|
||||
async def dispatch(self, owner, text, turn):
|
||||
device = self.store.by_owner(owner)
|
||||
if not device:
|
||||
return {"status": "unavailable", "turn_id": turn, "result": "未绑定设备或设备不可用。"}
|
||||
host = device["host_id"]
|
||||
await rate_limit(self.r, "dispatch:" + owner, 30)
|
||||
if len(self.pending) >= self.s.max_pending:
|
||||
raise HTTPException(503, "too many in-flight requests")
|
||||
presence = await self.r.get("hn:online:" + host)
|
||||
if not presence or await self.r.exists("hn:revoked:" + host):
|
||||
return {"status": "offline", "turn_id": turn, "result": "你的电脑当前离线,请开机并连接网络。"}
|
||||
try:
|
||||
presence = json.loads(presence)
|
||||
if fingerprint(presence["cert"]) != device["fingerprint"]:
|
||||
raise ValueError("certificate changed")
|
||||
public = verify_device(presence["cert"], self.s.ca_cert.read_bytes(), host)
|
||||
proof = verified(presence["proof"], public)
|
||||
if proof["host_id"] != host or proof["challenge"] != presence["challenge"]:
|
||||
raise ValueError("invalid device session")
|
||||
session = proof["session_id"]
|
||||
except Exception:
|
||||
self.store.audit(owner, "dispatch", host, "identity_rejected")
|
||||
raise HTTPException(409, "device identity rejected") from None
|
||||
if not self.store.begin_turn(turn, owner, host):
|
||||
return {"status": "duplicate", "turn_id": turn, "result": "该请求已接收,不会重复执行。"}
|
||||
private = x25519.X25519PrivateKey.generate()
|
||||
future = asyncio.get_running_loop().create_future()
|
||||
self.pending[turn] = Pending(future, private, public, host, session)
|
||||
envelope = seal({"type": "instruction", "turn_id": turn, "owner": owner,
|
||||
"text": text, "read_only": True, "channel": "im",
|
||||
"reply_key": raw_public(private.public_key())}, proof["kx"], self.signer,
|
||||
host_id=host, session_id=session)
|
||||
key = f"hn:inflight:{host}:{turn}"
|
||||
try:
|
||||
await self.r.set(key, session, ex=self.s.request_timeout + 5)
|
||||
count = await self.r.publish("hn:down:" + host, json.dumps({"type": "instruction", "envelope": envelope}))
|
||||
if not count:
|
||||
self.store.finish(turn, "offline")
|
||||
return {"status": "offline", "turn_id": turn, "result": "你的电脑当前离线。"}
|
||||
result = await asyncio.wait_for(future, timeout=self.s.request_timeout)
|
||||
self.store.finish(turn, "completed")
|
||||
self.store.audit(owner, "instruction", host, "completed")
|
||||
return result
|
||||
except asyncio.TimeoutError:
|
||||
self.store.finish(turn, "unknown")
|
||||
return {"status": "unknown", "turn_id": turn,
|
||||
"result": "等待结果超时,执行状态未知;不要直接重发有副作用的任务。"}
|
||||
finally:
|
||||
self.pending.pop(turn, None)
|
||||
await self.r.delete(key)
|
||||
|
||||
|
||||
def create_app(settings=None, redis=None, platform=None):
|
||||
s = settings or Settings()
|
||||
r = redis or Redis.from_url(s.redis_url, decode_responses=True)
|
||||
store = Store(s.data_dir / "metadata.sqlite", s.database_url)
|
||||
f = platform or Feishu(s)
|
||||
broker = Broker(s, r, store)
|
||||
oauth = OAuth(s, r, f)
|
||||
background = set()
|
||||
|
||||
def spawn(coro):
|
||||
task = asyncio.create_task(coro)
|
||||
background.add(task)
|
||||
task.add_done_callback(background.discard)
|
||||
# Retrieve errors without displaying possibly sensitive exception text.
|
||||
task.add_done_callback(lambda t: t.exception() if not t.cancelled() else None)
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app):
|
||||
await r.ping()
|
||||
for row in store.db.execute("SELECT host_id,fingerprint,revoked FROM devices").fetchall():
|
||||
await r.set("hn:device:" + row["host_id"], row["fingerprint"])
|
||||
if row["revoked"]:
|
||||
await r.set("hn:revoked:" + row["host_id"], "1")
|
||||
pub = r.pubsub()
|
||||
await pub.subscribe("hn:replies")
|
||||
reply_task = asyncio.create_task(broker.replies(pub))
|
||||
app.state.reply_task = reply_task
|
||||
async def sweep():
|
||||
while True:
|
||||
await asyncio.sleep(30)
|
||||
async with oauth.lock:
|
||||
oauth.prune()
|
||||
sweep_task = asyncio.create_task(sweep())
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
for task in [reply_task, sweep_task, *background]:
|
||||
task.cancel()
|
||||
await asyncio.gather(reply_task, sweep_task, *background, return_exceptions=True)
|
||||
await pub.aclose()
|
||||
await f.close()
|
||||
store.close()
|
||||
if redis is None:
|
||||
await r.aclose()
|
||||
|
||||
app = FastAPI(title="Hainuo B1 connector", lifespan=lifespan, docs_url=None, redoc_url=None)
|
||||
app.add_middleware(BodyLimitMiddleware, max_body=s.max_body)
|
||||
app.include_router(oauth.router)
|
||||
from .web_session import WebSessions
|
||||
web_sessions = WebSessions(s, r, store, broker, f)
|
||||
app.include_router(web_sessions.router)
|
||||
app.state.store, app.state.broker, app.state.oauth = store, broker, oauth
|
||||
app.state.platform, app.state.redis = f, r
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_error(request, exc):
|
||||
# FastAPI's default error response includes invalid input values (possibly tokens).
|
||||
return JSONResponse({"detail": "invalid request parameters"}, status_code=422)
|
||||
|
||||
@app.middleware("http")
|
||||
async def secure_response(request, call_next):
|
||||
return no_cache(await call_next(request))
|
||||
|
||||
def admin(request):
|
||||
require_secret(request.headers.get("X-Admin-Secret"), s.admin_secret)
|
||||
|
||||
@app.get("/health")
|
||||
async def health():
|
||||
return {"status": "alive", "role": "connector", "version": "0.1.0"}
|
||||
|
||||
@app.get("/ready")
|
||||
async def ready():
|
||||
await r.ping()
|
||||
store.db.execute("SELECT 1")
|
||||
if not getattr(app.state, "reply_task", None) or app.state.reply_task.done():
|
||||
raise HTTPException(503, "reply subscriber unavailable")
|
||||
return {"status": "ready"}
|
||||
|
||||
@app.post("/admin/devices", status_code=201)
|
||||
async def register(body: Register, request: Request):
|
||||
admin(request)
|
||||
try:
|
||||
verify_device(body.cert, s.ca_cert.read_bytes(), body.host_id)
|
||||
except Exception:
|
||||
raise HTTPException(400, "invalid device certificate") from None
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= s.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
try:
|
||||
fp = fingerprint(body.cert)
|
||||
store.add_device(body.host_id, body.cert, fp)
|
||||
except INTEGRITY_ERRORS:
|
||||
raise HTTPException(409, "device already exists") from None
|
||||
await r.set("hn:device:" + body.host_id, fp)
|
||||
store.audit("admin", "register", body.host_id, "success")
|
||||
return {"host_id": body.host_id, "fingerprint": fp}
|
||||
|
||||
@app.get("/admin/devices")
|
||||
async def devices(request: Request):
|
||||
admin(request)
|
||||
rows = store.db.execute("SELECT host_id,fingerprint,owner,revoked FROM devices ORDER BY host_id").fetchall()
|
||||
return {"devices": [{**dict(row), "online": bool(await r.exists("hn:online:" + row["host_id"]))} for row in rows]}
|
||||
|
||||
@app.post("/admin/devices/{host}/revoke")
|
||||
async def revoke(host: str, request: Request):
|
||||
admin(request)
|
||||
if not store.device(host):
|
||||
raise HTTPException(404, "device not found")
|
||||
# Persistent source of truth first; router block + disconnect follows.
|
||||
store.revoke(host)
|
||||
await r.incr("hn:web-generation:" + host)
|
||||
await r.set("hn:revoked:" + host, "1")
|
||||
await r.delete("hn:online:" + host)
|
||||
await r.publish("hn:kill:" + host, "revoke")
|
||||
for item in broker.pending.values():
|
||||
if item.host == host and not item.future.done():
|
||||
item.future.set_result({"status": "revoked", "result": "设备已停用,结果已丢弃。"})
|
||||
store.audit("admin", "revoke", host, "success")
|
||||
return {"status": "revoked"}
|
||||
|
||||
@app.post("/admin/reconcile")
|
||||
async def reconcile(request: Request):
|
||||
"""Rebuild router admission metadata after Redis recovery; no dialogue data."""
|
||||
admin(request)
|
||||
rows = store.db.execute("SELECT host_id,fingerprint,revoked FROM devices").fetchall()
|
||||
for row in rows:
|
||||
await r.set("hn:device:" + row["host_id"], row["fingerprint"])
|
||||
if row["revoked"]:
|
||||
await r.set("hn:revoked:" + row["host_id"], "1")
|
||||
return {"devices": len(rows)}
|
||||
|
||||
@app.post("/admin/devices/{host}/unbind")
|
||||
async def admin_unbind(host: str, request: Request):
|
||||
admin(request)
|
||||
device = store.device(host)
|
||||
if not device:
|
||||
raise HTTPException(404, "device not found")
|
||||
if device["owner"]:
|
||||
store.unbind(device["owner"])
|
||||
await r.incr("hn:web-generation:" + host)
|
||||
await r.delete("hn:online:" + host)
|
||||
await r.publish("hn:kill:" + host, "unbind")
|
||||
for item in broker.pending.values():
|
||||
if item.host == host and not item.future.done():
|
||||
item.future.set_result({"status": "unbound", "result": "设备已解绑,结果已丢弃。"})
|
||||
store.audit("admin", "unbind", host, "success")
|
||||
return {"status": "unbound", "host_id": host, "revoked": bool(device["revoked"])}
|
||||
|
||||
async def make_binding_code(owner):
|
||||
if store.by_owner(owner):
|
||||
return "你已绑定电脑,请先发送 /解绑。"
|
||||
await rate_limit(r, "binding:" + owner, 5)
|
||||
code = secrets.token_urlsafe(12)
|
||||
await r.set("hn:bind:" + hashlib.sha256(code.encode()).hexdigest(), owner, ex=300)
|
||||
return "请在本人电脑的桥接客户端输入绑定码(5分钟有效):" + code
|
||||
|
||||
@app.post("/device/bind")
|
||||
async def bind(body: Bind, request: Request):
|
||||
await rate_limit(r, "bind:" + peer(request), 20)
|
||||
device = store.device(body.host_id)
|
||||
if not device or device["revoked"]:
|
||||
raise HTTPException(404, "device unavailable")
|
||||
try:
|
||||
public = verify_device(device["cert"], s.ca_cert.read_bytes(), body.host_id)
|
||||
proof = verified(body.proof, public)
|
||||
if proof["host_id"] != body.host_id or abs(time.time() - proof["ts"]) > 90:
|
||||
raise ValueError("invalid proof")
|
||||
code = proof["code"]
|
||||
if not isinstance(code, str) or len(code) > 128:
|
||||
raise ValueError("invalid code")
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid device proof") from None
|
||||
key = "hn:bind:" + hashlib.sha256(code.encode()).hexdigest()
|
||||
owner = await r.get(key)
|
||||
if not owner:
|
||||
raise HTTPException(404, "binding code expired or consumed")
|
||||
# GETDEL is atomic across connectors. Invalid device proofs never reach this point.
|
||||
owner = await r.getdel(key)
|
||||
if not owner:
|
||||
raise HTTPException(404, "binding code consumed")
|
||||
try:
|
||||
store.bind(body.host_id, owner)
|
||||
except (*INTEGRITY_ERRORS, ValueError):
|
||||
raise HTTPException(409, "owner/device already bound; request new code") from None
|
||||
await r.incr("hn:web-generation:" + body.host_id)
|
||||
store.audit(owner, "bind", body.host_id, "success")
|
||||
return sign({"host_id": body.host_id, "owner": owner, "ts": int(time.time())}, broker.signer)
|
||||
|
||||
@app.post("/admin/test/binding-code")
|
||||
async def test_code(body: Instruction, request: Request):
|
||||
admin(request)
|
||||
if s.environment == "production":
|
||||
raise HTTPException(404, "not found")
|
||||
return {"message": await make_binding_code(body.open_id)}
|
||||
|
||||
@app.post("/admin/test/dispatch")
|
||||
async def test_dispatch(body: Instruction, request: Request):
|
||||
admin(request)
|
||||
if s.environment == "production":
|
||||
raise HTTPException(404, "not found")
|
||||
return await broker.dispatch(body.open_id, body.text, body.turn_id)
|
||||
|
||||
async def handle_event(data):
|
||||
header, event = data.get("header", {}), data.get("event", {})
|
||||
if header.get("event_type") != "im.message.receive_v1":
|
||||
return
|
||||
message, sender = event.get("message", {}), event.get("sender", {})
|
||||
owner = sender.get("sender_id", {}).get("open_id")
|
||||
message_id = message.get("message_id", "")
|
||||
if (message.get("chat_type") != "p2p" or message.get("message_type") != "text"
|
||||
or sender.get("sender_type") != "user" or not owner
|
||||
or not re.fullmatch(r"[A-Za-z0-9_-]{1,128}", message_id)):
|
||||
return
|
||||
if header.get("app_id") != s.feishu_app_id:
|
||||
return
|
||||
try:
|
||||
text = json.loads(message["content"])["text"].strip()
|
||||
if not text or len(text) > 8000:
|
||||
return
|
||||
# Persistent receipt BEFORE any side effect. Restarts do not execute a delivery twice.
|
||||
event_turn = "event_" + hashlib.sha256(message_id.encode()).hexdigest()
|
||||
if not store.begin_turn(event_turn, owner, "event"):
|
||||
return
|
||||
if text == "/绑定":
|
||||
result = await make_binding_code(owner)
|
||||
elif text == "/解绑":
|
||||
old = store.by_owner(owner)
|
||||
store.unbind(owner)
|
||||
if old:
|
||||
await r.incr("hn:web-generation:" + old["host_id"])
|
||||
await r.publish("hn:kill:" + old["host_id"], "unbind")
|
||||
for item in broker.pending.values():
|
||||
if item.host == old["host_id"] and not item.future.done():
|
||||
item.future.set_result({"status": "unbound", "result": "设备已解绑,结果已丢弃。"})
|
||||
result = "已解绑;重新绑定后请更新本机绑定信息。"
|
||||
elif text == "/主机名" or text.startswith("/回显 "):
|
||||
result = (await broker.dispatch(owner, text, "msg_" + hashlib.sha256(message_id.encode()).hexdigest()))["result"]
|
||||
else:
|
||||
result = "当前为企业身份接入联调:支持 /绑定、/解绑、/主机名、/回显 内容。Agent工具权限验收完成后再开放自然语言任务。"
|
||||
await f.reply(message_id, result[:s.max_result])
|
||||
store.finish(event_turn, "replied")
|
||||
except Exception:
|
||||
store.audit(owner, "event", message_id, "failed_or_unknown")
|
||||
|
||||
@app.post("/internal/events")
|
||||
async def internal_event(request: Request):
|
||||
require_secret(request.headers.get("X-Internal-Secret"), s.internal_secret)
|
||||
if not s.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
if len(background) >= s.max_pending:
|
||||
raise HTTPException(503, "busy")
|
||||
spawn(handle_event(await request.json()))
|
||||
return {"accepted": True}
|
||||
|
||||
@app.post("/feishu/event")
|
||||
async def webhook(request: Request):
|
||||
if not s.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
if not s.feishu_encrypt_key or not s.feishu_verification_token:
|
||||
raise HTTPException(503, "webhook credentials not configured; use selected event source")
|
||||
await rate_limit(r, "webhook:" + peer(request), 600)
|
||||
raw = await request.body()
|
||||
timestamp, nonce, signature = (request.headers.get(x, "") for x in
|
||||
("X-Lark-Request-Timestamp", "X-Lark-Request-Nonce", "X-Lark-Signature"))
|
||||
try:
|
||||
if abs(time.time() - int(timestamp)) > 300 or not nonce or len(nonce) > 128:
|
||||
raise ValueError("stale request")
|
||||
expected = hashlib.sha256((timestamp + nonce + s.feishu_encrypt_key).encode() + raw).hexdigest()
|
||||
if not hmac.compare_digest(expected, signature):
|
||||
raise ValueError("bad signature")
|
||||
data = json.loads(raw)
|
||||
if "encrypt" in data:
|
||||
cipher = base64.b64decode(data["encrypt"], validate=True)
|
||||
decryptor = Cipher(algorithms.AES(hashlib.sha256(s.feishu_encrypt_key.encode()).digest()),
|
||||
modes.CBC(cipher[:16])).decryptor()
|
||||
padded = decryptor.update(cipher[16:]) + decryptor.finalize()
|
||||
unpadder = padding.PKCS7(128).unpadder()
|
||||
data = json.loads(unpadder.update(padded) + unpadder.finalize())
|
||||
token = data.get("token", data.get("header", {}).get("token", ""))
|
||||
if not hmac.compare_digest(token, s.feishu_verification_token):
|
||||
raise ValueError("invalid verification token")
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid event authentication") from None
|
||||
if data.get("type") == "url_verification":
|
||||
return {"challenge": data.get("challenge", "")}
|
||||
# Same delivery is ACKed again; durable message_id receipt handles execution deduplication.
|
||||
if len(background) >= s.max_pending:
|
||||
raise HTTPException(503, "busy")
|
||||
spawn(handle_event(data))
|
||||
return {"code": 0}
|
||||
|
||||
@app.get("/api/whoami")
|
||||
async def whoami(request: Request):
|
||||
if not s.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
await rate_limit(r, "whoami:" + peer(request))
|
||||
auth = request.headers.get("Authorization", "")
|
||||
if not auth.startswith("Bearer ") or len(auth) > 8192:
|
||||
raise HTTPException(401, "user token required")
|
||||
try:
|
||||
info = await f.user_info(auth[7:])
|
||||
except PlatformError:
|
||||
raise HTTPException(401, "invalid user token") from None
|
||||
device = store.by_owner(info["open_id"])
|
||||
if not device:
|
||||
raise HTTPException(404, "no device bound")
|
||||
if not s.device_domain or not re.fullmatch(r"[a-zA-Z0-9.-]+", s.device_domain):
|
||||
raise HTTPException(503, "device web domain not configured")
|
||||
return {"host_id": device["host_id"], "url": f"https://h-{device['host_id']}.{s.device_domain}/",
|
||||
"online": bool(await r.exists("hn:online:" + device["host_id"])),
|
||||
"device_login_required": True}
|
||||
|
||||
@app.get("/h5", response_class=HTMLResponse)
|
||||
async def h5():
|
||||
from importlib.resources import files
|
||||
return HTMLResponse(files("relay").joinpath("web/index.html").read_text(encoding="utf-8"),
|
||||
headers={"Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self'; frame-ancestors 'self'; base-uri 'none'; form-action 'self'"})
|
||||
|
||||
@app.get("/assets/{name}")
|
||||
async def asset(name: str):
|
||||
from importlib.resources import files
|
||||
from starlette.responses import Response
|
||||
if name not in {"app.js", "style.css"}:
|
||||
raise HTTPException(404, "not found")
|
||||
return Response(files("relay").joinpath("web/" + name).read_bytes(),
|
||||
media_type="text/javascript" if name.endswith(".js") else "text/css")
|
||||
|
||||
@app.get("/proxy")
|
||||
async def proxy(request: Request):
|
||||
if not s.proxy_enabled or not s.feishu_enabled:
|
||||
raise HTTPException(404, "not found")
|
||||
auth = request.headers.get("Authorization", "")
|
||||
target = request.headers.get("X-Relay-Target", "")
|
||||
decoded = unquote(target)
|
||||
parts = urlsplit(target)
|
||||
allowed = s.proxy_paths.split(",")
|
||||
if (not auth.startswith("Bearer ") or len(auth) > 8192 or len(target) > 4096
|
||||
or parts.scheme or parts.netloc or parts.fragment or target.startswith("//")
|
||||
or any(x in decoded for x in ("..", "\\", "\r", "\n", "#", "%"))
|
||||
or not any(parts.path == x or parts.path.startswith(x + "/") for x in allowed)):
|
||||
raise HTTPException(403, "target not allowed")
|
||||
try:
|
||||
info = await f.user_info(auth[7:])
|
||||
await rate_limit(r, "proxy:" + info["open_id"], 60)
|
||||
# Buffer bounded response; no disk/cache, redirects never followed.
|
||||
async with f.http.stream("GET", target, headers={"Authorization": auth}) as response:
|
||||
if response.status_code in {301, 302, 303, 307, 308}:
|
||||
raise HTTPException(502, "upstream redirect refused")
|
||||
chunks, size = [], 0
|
||||
async for chunk in response.aiter_bytes():
|
||||
size += len(chunk)
|
||||
if size > 2 * 1024 * 1024:
|
||||
raise HTTPException(502, "response too large")
|
||||
chunks.append(chunk)
|
||||
from starlette.responses import Response
|
||||
store.audit(info["open_id"], "proxy", parts.path, str(response.status_code))
|
||||
return Response(b"".join(chunks), status_code=response.status_code,
|
||||
media_type=response.headers.get("content-type", "application/json"))
|
||||
except PlatformError:
|
||||
raise HTTPException(401, "invalid user token") from None
|
||||
|
||||
return app
|
||||
@@ -0,0 +1,134 @@
|
||||
"""Signed ephemeral X25519 envelopes. The router never receives plaintext keys."""
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from cryptography import x509
|
||||
from cryptography.hazmat.primitives import hashes, serialization
|
||||
from cryptography.hazmat.primitives.asymmetric import ed25519, x25519
|
||||
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
|
||||
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
|
||||
from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
|
||||
|
||||
|
||||
def b64(data: bytes) -> str:
|
||||
return base64.urlsafe_b64encode(data).decode()
|
||||
|
||||
|
||||
def unb64(data: str) -> bytes:
|
||||
return base64.b64decode(data.encode(), altchars=b"-_", validate=True)
|
||||
|
||||
|
||||
def canonical(data: dict) -> bytes:
|
||||
return json.dumps(data, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
|
||||
|
||||
|
||||
def raw_public(key) -> str:
|
||||
return b64(key.public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw))
|
||||
|
||||
|
||||
def pem_private(key) -> bytes:
|
||||
return key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
|
||||
serialization.NoEncryption())
|
||||
|
||||
|
||||
def load_private(path):
|
||||
return serialization.load_pem_private_key(path.read_bytes(), password=None)
|
||||
|
||||
|
||||
def load_public(path):
|
||||
return serialization.load_pem_public_key(path.read_bytes())
|
||||
|
||||
|
||||
def fingerprint(pem: str) -> str:
|
||||
return x509.load_pem_x509_certificate(pem.encode()).fingerprint(hashes.SHA256()).hex()
|
||||
|
||||
|
||||
def verify_device(pem: str, ca_pem: bytes, host_id: str):
|
||||
"""v1 deliberately accepts only directly issued Ed25519 device certificates."""
|
||||
cert = x509.load_pem_x509_certificate(pem.encode())
|
||||
ca = x509.load_pem_x509_certificate(ca_pem)
|
||||
now = datetime.now(timezone.utc)
|
||||
if not (ca.not_valid_before_utc <= now <= ca.not_valid_after_utc):
|
||||
raise ValueError("expired CA")
|
||||
if not ca.extensions.get_extension_for_class(x509.BasicConstraints).value.ca:
|
||||
raise ValueError("not a CA")
|
||||
cert.verify_directly_issued_by(ca)
|
||||
if not (cert.not_valid_before_utc <= now <= cert.not_valid_after_utc):
|
||||
raise ValueError("expired certificate")
|
||||
if cert.extensions.get_extension_for_class(x509.BasicConstraints).value.ca:
|
||||
raise ValueError("CA cannot be used as device")
|
||||
if ExtendedKeyUsageOID.CLIENT_AUTH not in cert.extensions.get_extension_for_class(x509.ExtendedKeyUsage).value:
|
||||
raise ValueError("clientAuth missing")
|
||||
names = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
|
||||
if names.get_values_for_type(x509.UniformResourceIdentifier) != [f"urn:hainuo:host:{host_id}"]:
|
||||
raise ValueError("host identity mismatch")
|
||||
public = cert.public_key()
|
||||
if not isinstance(public, ed25519.Ed25519PublicKey):
|
||||
raise ValueError("v1 requires Ed25519 device key")
|
||||
return public
|
||||
|
||||
|
||||
def sign(data: dict, key) -> dict:
|
||||
return {**data, "signature": b64(key.sign(canonical(data)))}
|
||||
|
||||
|
||||
def verified(data: dict, key) -> dict:
|
||||
body = {k: v for k, v in data.items() if k != "signature"}
|
||||
key.verify(unb64(data["signature"]), canonical(body))
|
||||
return body
|
||||
|
||||
|
||||
def seal(payload: dict, recipient_public: str, signer, *, host_id: str, session_id: str) -> dict:
|
||||
ephemeral = x25519.X25519PrivateKey.generate()
|
||||
header = {"v": 1, "host_id": host_id, "session_id": session_id,
|
||||
"ts": int(time.time()), "nonce": b64(secrets.token_bytes(12)),
|
||||
"ephemeral": raw_public(ephemeral.public_key())}
|
||||
shared = ephemeral.exchange(x25519.X25519PublicKey.from_public_bytes(unb64(recipient_public)))
|
||||
key = HKDF(algorithm=hashes.SHA256(), length=32, salt=session_id.encode(),
|
||||
info=b"hainuo-relay-envelope-v1").derive(shared)
|
||||
cipher = AESGCM(key).encrypt(unb64(header["nonce"]), canonical(payload), canonical(header))
|
||||
return sign({**header, "ciphertext": b64(cipher)}, signer)
|
||||
|
||||
|
||||
def open_envelope(envelope: dict, recipient_private, sender_public, *, host_id: str, session_id: str) -> dict:
|
||||
body = verified(envelope, sender_public)
|
||||
if body["v"] != 1 or body["host_id"] != host_id or body["session_id"] != session_id:
|
||||
raise ValueError("wrong destination/session")
|
||||
if abs(time.time() - body["ts"]) > 90:
|
||||
raise ValueError("expired envelope")
|
||||
header = {k: v for k, v in body.items() if k != "ciphertext"}
|
||||
shared = recipient_private.exchange(x25519.X25519PublicKey.from_public_bytes(unb64(body["ephemeral"])))
|
||||
key = HKDF(algorithm=hashes.SHA256(), length=32, salt=session_id.encode(),
|
||||
info=b"hainuo-relay-envelope-v1").derive(shared)
|
||||
plain = AESGCM(key).decrypt(unb64(body["nonce"]), unb64(body["ciphertext"]), canonical(header))
|
||||
return json.loads(plain)
|
||||
|
||||
|
||||
def issue_ca():
|
||||
key = ed25519.Ed25519PrivateKey.generate()
|
||||
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Hainuo device test CA")])
|
||||
now = datetime.now(timezone.utc)
|
||||
cert = (x509.CertificateBuilder().subject_name(name).issuer_name(name)
|
||||
.public_key(key.public_key()).serial_number(x509.random_serial_number())
|
||||
.not_valid_before(now - timedelta(minutes=5)).not_valid_after(now + timedelta(days=3650))
|
||||
.add_extension(x509.BasicConstraints(ca=True, path_length=0), critical=True)
|
||||
.add_extension(x509.KeyUsage(False, False, False, False, False, True, True, False, False), critical=True)
|
||||
.sign(key, algorithm=None))
|
||||
return key, cert
|
||||
|
||||
|
||||
def issue_device(ca_key, ca_cert, host_id: str, public_key, days=30):
|
||||
now = datetime.now(timezone.utc)
|
||||
return (x509.CertificateBuilder()
|
||||
.subject_name(x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, host_id)]))
|
||||
.issuer_name(ca_cert.subject).public_key(public_key)
|
||||
.serial_number(x509.random_serial_number())
|
||||
.not_valid_before(now - timedelta(minutes=5)).not_valid_after(now + timedelta(days=days))
|
||||
.add_extension(x509.BasicConstraints(ca=False, path_length=None), critical=True)
|
||||
.add_extension(x509.SubjectAlternativeName([x509.UniformResourceIdentifier(f"urn:hainuo:host:{host_id}")]), critical=False)
|
||||
.add_extension(x509.ExtendedKeyUsage([ExtendedKeyUsageOID.CLIENT_AUTH]), critical=False)
|
||||
.sign(ca_key, algorithm=None))
|
||||
@@ -0,0 +1,206 @@
|
||||
"""Reference PC bridge. No shell/PowerShell execution; local read-only diagnostics."""
|
||||
import asyncio
|
||||
import contextlib
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import socket
|
||||
import sqlite3
|
||||
import time
|
||||
from pathlib import Path
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
import httpx
|
||||
from cryptography.hazmat.primitives.asymmetric import x25519
|
||||
from websockets.asyncio.client import connect
|
||||
|
||||
from .crypto import (load_private, load_public, open_envelope, raw_public, seal, sign,
|
||||
verified, verify_device)
|
||||
|
||||
|
||||
class DeviceJournal:
|
||||
def __init__(self, path):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.db = sqlite3.connect(path)
|
||||
self.db.execute("CREATE TABLE IF NOT EXISTS consumed(turn_id TEXT PRIMARY KEY, ts REAL NOT NULL)")
|
||||
self.db.commit()
|
||||
|
||||
def consume(self, turn):
|
||||
with self.db:
|
||||
return self.db.execute("INSERT OR IGNORE INTO consumed VALUES(?,?)", (turn, time.time())).rowcount == 1
|
||||
|
||||
def close(self):
|
||||
self.db.close()
|
||||
|
||||
|
||||
async def execute_readonly(text, root: Path | None):
|
||||
if text in {"/主机名", "hostname"}:
|
||||
return socket.gethostname()
|
||||
if text.startswith("/回显 "):
|
||||
return text[4:][:16000]
|
||||
if text.startswith("/读取 "):
|
||||
if root is None:
|
||||
return "未配置测试文件目录。"
|
||||
base = root.resolve(strict=True)
|
||||
try:
|
||||
path = (base / text[4:].strip()).resolve(strict=True)
|
||||
if path == base or not path.is_relative_to(base) or not path.is_file():
|
||||
return "拒绝:文件不在允许的测试目录。"
|
||||
if path.stat().st_size > 32768:
|
||||
return "拒绝:测试文件超过32KB。"
|
||||
return path.read_text(encoding="utf-8")[:16000]
|
||||
except (OSError, UnicodeError, ValueError):
|
||||
return "拒绝:文件不存在、不可读或不是UTF-8文本。"
|
||||
return "当前桥接客户端仅开放只读诊断:/主机名、/回显 内容、/读取 相对路径;尚未接入海诺本地Agent接口。"
|
||||
|
||||
|
||||
class LocalAgent:
|
||||
"""Explicit adapter contract, not a claim of compatibility with installer 1.065."""
|
||||
def __init__(self, url, transport=None):
|
||||
parts = urlsplit(url)
|
||||
if parts.scheme != "http" or parts.hostname not in {"127.0.0.1", "::1"} or parts.username or parts.password or parts.fragment:
|
||||
raise ValueError("local Agent must use a fixed loopback HTTP endpoint")
|
||||
self.url = url
|
||||
self.http = httpx.AsyncClient(timeout=30, follow_redirects=False, transport=transport, trust_env=False)
|
||||
|
||||
async def execute(self, text, owner, turn):
|
||||
headers = {}
|
||||
if os.environ.get("HN_LOCAL_AGENT_TOKEN"):
|
||||
headers["Authorization"] = "Bearer " + os.environ["HN_LOCAL_AGENT_TOKEN"]
|
||||
try:
|
||||
async with self.http.stream("POST", self.url, headers=headers,
|
||||
json={"text": text, "open_id": owner, "turn_id": turn,
|
||||
"channel": "im", "read_only": True}) as response:
|
||||
if response.status_code != 200:
|
||||
return "本机Agent未返回成功结果,请查看本机服务状态。"
|
||||
body = b""
|
||||
async for chunk in response.aiter_bytes():
|
||||
body += chunk
|
||||
if len(body) > 65536:
|
||||
return "本机Agent结果超过限制。"
|
||||
result = json.loads(body)["result"]
|
||||
if not isinstance(result, str):
|
||||
return "本机Agent响应格式不匹配。"
|
||||
return result[:16000]
|
||||
except (httpx.HTTPError, ValueError, KeyError):
|
||||
return "本机Agent连接失败或响应格式不匹配。"
|
||||
|
||||
async def close(self):
|
||||
await self.http.aclose()
|
||||
|
||||
|
||||
async def bind_device(directory: Path, connector_url: str, code: str, *, tls_verify=True):
|
||||
config = json.loads((directory / "device.json").read_text(encoding="utf-8"))
|
||||
private = load_private(directory / "device.key")
|
||||
proof = sign({"host_id": config["host_id"], "code": code, "ts": int(time.time())}, private)
|
||||
async with httpx.AsyncClient(verify=tls_verify, follow_redirects=False, timeout=15) as http:
|
||||
response = await http.post(connector_url.rstrip("/") + "/device/bind",
|
||||
json={"host_id": config["host_id"], "proof": proof})
|
||||
if response.status_code != 200:
|
||||
raise RuntimeError(f"binding failed: HTTP {response.status_code}")
|
||||
receipt = verified(response.json(), load_public(directory / "connector.pub"))
|
||||
if receipt["host_id"] != config["host_id"]:
|
||||
raise ValueError("wrong binding receipt")
|
||||
config["owner"] = receipt["owner"]
|
||||
temp = directory / "device.json.tmp"
|
||||
temp.write_text(json.dumps(config, ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
temp.replace(directory / "device.json")
|
||||
|
||||
|
||||
async def pair_browser(directory: Path, connector_url: str, *, tls_verify=True):
|
||||
config = json.loads((directory / "device.json").read_text(encoding="utf-8-sig"))
|
||||
if not config.get("owner"):
|
||||
raise RuntimeError("device must be bound first")
|
||||
key = load_private(directory / "device.key")
|
||||
proof = sign({"host_id": config["host_id"], "owner": config["owner"],
|
||||
"purpose": "h5-pair-v1", "ts": int(time.time()), "nonce": secrets.token_hex(16)}, key)
|
||||
async with httpx.AsyncClient(verify=tls_verify, trust_env=False, follow_redirects=False, timeout=15) as client:
|
||||
response = await client.post(connector_url.rstrip("/") + "/device/web-pair",
|
||||
json={"host_id": config["host_id"], "proof": proof})
|
||||
if response.status_code != 200:
|
||||
raise RuntimeError(f"browser pairing failed: HTTP {response.status_code}")
|
||||
result = verified(response.json(), load_public(directory / "connector.pub"))
|
||||
if result["host_id"] != config["host_id"]:
|
||||
raise ValueError("wrong pairing receipt")
|
||||
return result
|
||||
|
||||
|
||||
async def run_device(directory: Path, router_url: str, *, root=None, once=False, ssl_context=None,
|
||||
stop_event=None, connected_event=None, agent_url=None, hainuo_config=None):
|
||||
config = json.loads((directory / "device.json").read_text(encoding="utf-8"))
|
||||
if not config.get("owner"):
|
||||
raise RuntimeError("bind device before starting")
|
||||
host, owner = config["host_id"], config["owner"]
|
||||
key = load_private(directory / "device.key")
|
||||
connector = load_public(directory / "connector.pub")
|
||||
cert = (directory / "device.pem").read_text(encoding="utf-8")
|
||||
verify_device(cert, (directory / "ca.pem").read_bytes(), host)
|
||||
journal = DeviceJournal(directory / "journal.sqlite")
|
||||
if agent_url and hainuo_config:
|
||||
raise ValueError("choose one Agent adapter")
|
||||
if hainuo_config:
|
||||
from .hainuo1065 import Hainuo1065Agent
|
||||
agent = Hainuo1065Agent(hainuo_config)
|
||||
else:
|
||||
agent = LocalAgent(agent_url) if agent_url else None
|
||||
stop_event = stop_event or asyncio.Event()
|
||||
delay = 1
|
||||
try:
|
||||
while not stop_event.is_set():
|
||||
try:
|
||||
kwargs = {"ssl": ssl_context} if router_url.startswith("wss://") and ssl_context else {}
|
||||
async with connect(router_url, max_size=262144, open_timeout=10, ping_interval=10,
|
||||
proxy=None, **kwargs) as ws:
|
||||
challenge = json.loads(await ws.recv())["challenge"]
|
||||
ephemeral = x25519.X25519PrivateKey.generate()
|
||||
session = secrets.token_hex(16)
|
||||
proof = sign({"host_id": host, "session_id": session, "challenge": challenge,
|
||||
"kx": raw_public(ephemeral.public_key()), "ts": int(time.time())}, key)
|
||||
await ws.send(json.dumps({"host_id": host, "cert": cert, "proof": proof}))
|
||||
accepted = json.loads(await ws.recv())
|
||||
if accepted.get("type") != "connected":
|
||||
raise RuntimeError("device connection rejected")
|
||||
if connected_event:
|
||||
connected_event.set()
|
||||
delay = 1
|
||||
while not stop_event.is_set():
|
||||
try:
|
||||
raw = await asyncio.wait_for(ws.recv(), timeout=1)
|
||||
except asyncio.TimeoutError:
|
||||
continue
|
||||
data = json.loads(raw)
|
||||
payload = open_envelope(data["envelope"], ephemeral, connector,
|
||||
host_id=host, session_id=session)
|
||||
if payload.get("owner") != owner or payload.get("type") != "instruction":
|
||||
continue
|
||||
turn = payload["turn_id"]
|
||||
if not isinstance(turn, str) or len(turn) > 128:
|
||||
continue
|
||||
if not journal.consume(turn):
|
||||
result = "该请求已处理,拒绝重复执行。"
|
||||
elif payload.get("read_only") is not True or payload.get("channel") != "im":
|
||||
result = "拒绝:通道或操作类型不受支持。"
|
||||
else:
|
||||
if agent and payload["text"].startswith("/助手 "):
|
||||
result = await agent.execute(payload["text"][4:], owner, turn)
|
||||
else:
|
||||
result = await execute_readonly(payload["text"], root)
|
||||
reply = seal({"type": "result", "turn_id": turn, "result": result},
|
||||
payload["reply_key"], key, host_id=host, session_id=session)
|
||||
await ws.send(json.dumps({"type": "reply", "turn_id": turn, "envelope": reply}))
|
||||
if once:
|
||||
return
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except Exception:
|
||||
if once:
|
||||
raise
|
||||
# No payloads/URLs/credentials in logs, bounded reconnect backoff + jitter.
|
||||
print("设备连接中断,等待重连。", flush=True)
|
||||
with contextlib.suppress(asyncio.TimeoutError):
|
||||
await asyncio.wait_for(stop_event.wait(), timeout=delay + secrets.randbelow(1000) / 1000)
|
||||
delay = min(delay * 2, 30)
|
||||
finally:
|
||||
journal.close()
|
||||
if agent:
|
||||
await agent.close()
|
||||
@@ -0,0 +1,107 @@
|
||||
"""Adapter for the native API actually found in installer 1.065.
|
||||
|
||||
Loopback only, independent API key, no platform secrets, no redirects or retries.
|
||||
The included native launcher offers only text inference with no tools.
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
from pathlib import Path
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
import httpx
|
||||
|
||||
|
||||
class NativeAPIError(RuntimeError):
|
||||
"""Contains a sanitized status only, never response body or credentials."""
|
||||
|
||||
|
||||
def read_native_config(path):
|
||||
path = Path(path)
|
||||
data = json.loads(path.read_text(encoding="utf-8-sig"))
|
||||
url = data.get("url", "")
|
||||
parts = urlsplit(url)
|
||||
if (parts.scheme != "http" or parts.hostname != "127.0.0.1" or not parts.port
|
||||
or parts.username or parts.password or parts.query or parts.fragment
|
||||
or parts.path not in {"", "/"}):
|
||||
raise ValueError("native API must be a fixed IPv4 loopback HTTP base URL")
|
||||
if not isinstance(data.get("api_key"), str) or len(data["api_key"]) < 32:
|
||||
raise ValueError("native API requires a dedicated key of at least 32 characters")
|
||||
if data.get("mode") not in {"text-only", "profile-tools"}:
|
||||
raise ValueError("unsupported native API mode")
|
||||
data["url"] = url.rstrip("/")
|
||||
return data
|
||||
|
||||
|
||||
class Hainuo1065Agent:
|
||||
def __init__(self, config_path, transport=None):
|
||||
self.config = read_native_config(config_path)
|
||||
self.http = httpx.AsyncClient(base_url=self.config["url"], timeout=120,
|
||||
follow_redirects=False, trust_env=False, transport=transport)
|
||||
self.headers = {"Authorization": "Bearer " + self.config["api_key"]}
|
||||
|
||||
async def _json(self, method, path, **kwargs):
|
||||
try:
|
||||
async with self.http.stream(method, path, headers={**self.headers, **kwargs.pop("headers", {})}, **kwargs) as response:
|
||||
if response.status_code != 200:
|
||||
raise NativeAPIError(f"native API HTTP {response.status_code}")
|
||||
body = bytearray()
|
||||
async for chunk in response.aiter_bytes():
|
||||
body.extend(chunk)
|
||||
if len(body) > 262144:
|
||||
raise NativeAPIError("native API response exceeds limit")
|
||||
data = json.loads(body)
|
||||
if not isinstance(data, dict):
|
||||
raise NativeAPIError("native API response is not an object")
|
||||
return data
|
||||
except (httpx.HTTPError, ValueError):
|
||||
raise NativeAPIError("native API connection/JSON failure") from None
|
||||
|
||||
async def probe(self):
|
||||
health = await self._json("GET", "/health")
|
||||
if health.get("platform") != "hermes-agent" or health.get("status") != "ok":
|
||||
raise NativeAPIError("endpoint is not the native Hermes API")
|
||||
capabilities = await self._json("GET", "/v1/capabilities")
|
||||
policy = capabilities.get("hainuo_relay_policy", {})
|
||||
# A stock unrestricted API endpoint is deliberately not sufficient.
|
||||
expected_mode = self.config["mode"]
|
||||
expected_tools = "profile" if expected_mode == "profile-tools" else "disabled"
|
||||
if policy != {"mode": expected_mode, "tools": expected_tools, "contract": "hainuo-1065-v1"}:
|
||||
raise NativeAPIError("native API policy missing; start the supplied restricted launcher")
|
||||
models = await self._json("GET", "/v1/models")
|
||||
model = self.config.get("model")
|
||||
available = models.get("data")
|
||||
if not isinstance(available, list) or not available or not all(isinstance(x, dict) and isinstance(x.get("id"), str) for x in available):
|
||||
raise NativeAPIError("native model list invalid")
|
||||
if model and model not in {x["id"] for x in available}:
|
||||
raise NativeAPIError("configured model alias unavailable")
|
||||
self.model = model or available[0]["id"]
|
||||
return {"status": "ready", "platform": "hermes-agent", "model": self.model,
|
||||
"mode": expected_mode, "version": health.get("version", "unknown")}
|
||||
|
||||
async def execute(self, text, owner, turn):
|
||||
try:
|
||||
# Recheck the actual local service before each inference, including reconnects.
|
||||
await self.probe()
|
||||
digest = hashlib.sha256((owner + "\0" + turn).encode()).hexdigest()
|
||||
data = await self._json("POST", "/v1/chat/completions",
|
||||
headers={"Idempotency-Key": "hn-" + digest},
|
||||
json={"model": self.model, "stream": False,
|
||||
"messages": [{"role": "user", "content": text}]})
|
||||
choices = data.get("choices")
|
||||
if not isinstance(choices, list) or not choices or not isinstance(choices[0], dict):
|
||||
raise NativeAPIError("native completion choices missing")
|
||||
choice = choices[0]
|
||||
message = choice.get("message", {})
|
||||
if (choice.get("finish_reason") != "stop" or message.get("tool_calls")
|
||||
or not isinstance(message.get("content"), str)
|
||||
or data.get("hermes", {}).get("failed")
|
||||
or data.get("hermes", {}).get("partial")):
|
||||
raise NativeAPIError("native completion incomplete or unexpected tool call")
|
||||
return message["content"][:16000]
|
||||
except NativeAPIError as error:
|
||||
# Safe generated error strings only; never echo upstream model/API errors.
|
||||
return "海诺原生接口未完成请求:" + str(error) + "。未自动重试。"
|
||||
|
||||
async def close(self):
|
||||
await self.http.aclose()
|
||||
@@ -0,0 +1,74 @@
|
||||
"""Optional official SDK event source, private platform domain explicitly configured."""
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
|
||||
import httpx
|
||||
import redis
|
||||
from .config import Settings
|
||||
|
||||
|
||||
def main():
|
||||
import lark_oapi as lark
|
||||
s = Settings(role="longconn")
|
||||
if not s.feishu_enabled or s.feishu_event_source != "longconn":
|
||||
raise RuntimeError("platform is disabled")
|
||||
# The SDK may log websocket URLs, tokens or event bodies. Disable its logging entirely.
|
||||
logging.disable(logging.CRITICAL)
|
||||
r = redis.Redis.from_url(s.redis_url)
|
||||
lease = r.lock("hn:longconn:leader", timeout=30, thread_local=False)
|
||||
if not lease.acquire(blocking=False):
|
||||
raise RuntimeError("another long-connection consumer owns the lease")
|
||||
url = os.environ.get("HN_CONNECTOR_INTERNAL_URL", "http://connector:8000")
|
||||
client = httpx.Client(base_url=url, timeout=10, follow_redirects=False)
|
||||
done = threading.Event()
|
||||
|
||||
def maintain_lease():
|
||||
while not done.wait(8):
|
||||
try:
|
||||
lease.extend(30, replace_ttl=True)
|
||||
except Exception:
|
||||
# Fail closed. Continuing after lease loss could create two consumers.
|
||||
os._exit(2)
|
||||
|
||||
threading.Thread(target=maintain_lease, daemon=True).start()
|
||||
|
||||
def received(event):
|
||||
data = json.loads(lark.JSON.marshal(event))
|
||||
response = client.post("/internal/events", headers={"X-Internal-Secret": s.internal_secret}, json=data)
|
||||
if response.status_code != 200:
|
||||
raise RuntimeError("connector did not accept event")
|
||||
print(json.dumps({"event": "platform_event_accepted", "type": data.get("header", {}).get("event_type")}), flush=True)
|
||||
|
||||
handler = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(received).build()
|
||||
class ObservableClient(lark.ws.Client):
|
||||
async def _connect(self):
|
||||
try:
|
||||
await super()._connect()
|
||||
if self._conn is not None:
|
||||
print(json.dumps({"event": "platform_connected", "api_host": s.feishu_api_base}), flush=True)
|
||||
except Exception as error:
|
||||
print(json.dumps({"event": "platform_connect_failed", "error_type": type(error).__name__}), flush=True)
|
||||
raise
|
||||
|
||||
try:
|
||||
# domain is an actual supported SDK argument; no public-cloud-domain monkey patch.
|
||||
ObservableClient(s.feishu_app_id, s.feishu_app_secret, event_handler=handler,
|
||||
domain=s.feishu_api_base.rstrip("/"), log_level=lark.LogLevel.ERROR).start()
|
||||
finally:
|
||||
done.set()
|
||||
client.close()
|
||||
try:
|
||||
lease.release()
|
||||
except redis.exceptions.LockError:
|
||||
pass
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
main()
|
||||
except Exception as error:
|
||||
print(json.dumps({"event": "platform_consumer_stopped", "error_type": type(error).__name__}), flush=True)
|
||||
raise SystemExit(1) from None
|
||||
@@ -0,0 +1,127 @@
|
||||
import asyncio
|
||||
import hashlib
|
||||
import hmac
|
||||
import secrets
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
from urllib.parse import urlencode
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from fastapi.responses import HTMLResponse, JSONResponse
|
||||
from pydantic import BaseModel, Field
|
||||
from .common import no_cache, peer, rate_limit
|
||||
from .platform import PlatformError
|
||||
|
||||
|
||||
@dataclass
|
||||
class Transaction:
|
||||
secret_hash: str
|
||||
expires: float
|
||||
status: str = "waiting"
|
||||
result: dict | None = None
|
||||
|
||||
|
||||
class Empty(BaseModel):
|
||||
pass
|
||||
|
||||
|
||||
class Refresh(BaseModel):
|
||||
refresh_token: str = Field(min_length=1, max_length=4096)
|
||||
|
||||
|
||||
class OAuth:
|
||||
"""A single connector process owns transactions and tokens in memory only."""
|
||||
def __init__(self, settings, redis, platform):
|
||||
self.settings, self.redis, self.platform = settings, redis, platform
|
||||
self.pending: dict[str, Transaction] = {}
|
||||
self.lock = asyncio.Lock()
|
||||
self.router = APIRouter()
|
||||
self.router.add_api_route("/oauth/start", self.start, methods=["POST"], status_code=201)
|
||||
self.router.add_api_route("/oauth/cb", self.callback, methods=["GET"])
|
||||
self.router.add_api_route("/oauth/claim", self.claim, methods=["GET"])
|
||||
self.router.add_api_route("/oauth/pending", self.status, methods=["GET"])
|
||||
self.router.add_api_route("/oauth/refresh", self.refresh, methods=["POST"])
|
||||
|
||||
def prune(self):
|
||||
now = time.monotonic()
|
||||
for state in list(self.pending):
|
||||
if self.pending[state].expires <= now:
|
||||
del self.pending[state]
|
||||
|
||||
def authenticated(self, state, secret):
|
||||
self.prune()
|
||||
item = self.pending.get(state)
|
||||
digest = hashlib.sha256((secret or "").encode()).hexdigest()
|
||||
if not item or not hmac.compare_digest(item.secret_hash, digest):
|
||||
raise HTTPException(404, "transaction not found")
|
||||
return item
|
||||
|
||||
async def start(self, body: Empty, request: Request):
|
||||
if not self.settings.feishu_enabled or not self.settings.oauth_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
await rate_limit(self.redis, "oauth:start:" + peer(request), 20)
|
||||
async with self.lock:
|
||||
self.prune()
|
||||
if len(self.pending) >= self.settings.max_pending:
|
||||
raise HTTPException(503, "too many pending transactions")
|
||||
state, secret = secrets.token_urlsafe(32), secrets.token_urlsafe(32)
|
||||
self.pending[state] = Transaction(hashlib.sha256(secret.encode()).hexdigest(), time.monotonic() + 600)
|
||||
redirect = self.settings.public_url.rstrip("/") + "/oauth/cb"
|
||||
url = self.settings.feishu_authorize_url + "?" + urlencode({"app_id": self.settings.feishu_app_id,
|
||||
"redirect_uri": redirect, "state": state})
|
||||
return no_cache(JSONResponse({"state": state, "claim_secret": secret, "authorization_url": url,
|
||||
"redirect_uri": redirect, "expires_in": 600,
|
||||
"code_ttl": 60, "poll_interval": 2}, status_code=201))
|
||||
|
||||
async def callback(self, request: Request, state: str = "", code: str = ""):
|
||||
await rate_limit(self.redis, "oauth:cb:" + peer(request))
|
||||
async with self.lock:
|
||||
self.prune()
|
||||
item = self.pending.get(state)
|
||||
if not code or len(code) > 4096 or not item or item.status != "waiting":
|
||||
raise HTTPException(400, "invalid callback")
|
||||
item.status = "exchanging"
|
||||
try:
|
||||
result = await self.platform.exchange(code)
|
||||
except PlatformError:
|
||||
async with self.lock:
|
||||
item.status = "failed"
|
||||
raise HTTPException(502, "authorization exchange failed") from None
|
||||
async with self.lock:
|
||||
if state not in self.pending or item.expires <= time.monotonic():
|
||||
self.pending.pop(state, None)
|
||||
raise HTTPException(400, "authorization expired")
|
||||
item.result, item.status = result, "ready"
|
||||
return no_cache(HTMLResponse("<meta charset='utf-8'><p>授权完成,请返回客户端。</p>"))
|
||||
|
||||
async def claim(self, request: Request, state: str):
|
||||
await rate_limit(self.redis, "oauth:claim:" + peer(request))
|
||||
async with self.lock:
|
||||
item = self.authenticated(state, request.headers.get("X-OAuth-Claim-Secret"))
|
||||
if item.status == "failed":
|
||||
del self.pending[state]
|
||||
raise HTTPException(502, "authorization failed")
|
||||
if item.status != "ready":
|
||||
return no_cache(JSONResponse({"status": "waiting", "retry_after": 2}, status_code=202))
|
||||
del self.pending[state]
|
||||
return no_cache(JSONResponse({"status": "claimed", **item.result}))
|
||||
|
||||
async def status(self, request: Request, state: str):
|
||||
await rate_limit(self.redis, "oauth:pending:" + peer(request))
|
||||
async with self.lock:
|
||||
item = self.authenticated(state, request.headers.get("X-OAuth-Claim-Secret"))
|
||||
return no_cache(JSONResponse({"status": item.status}))
|
||||
|
||||
async def refresh(self, body: Refresh, request: Request):
|
||||
if not self.settings.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
await rate_limit(self.redis, "oauth:refresh:" + peer(request), 20)
|
||||
# Lock and consume before the upstream call; ambiguous failures never retry an old refresh token.
|
||||
digest = hashlib.sha256(body.refresh_token.encode()).hexdigest()
|
||||
if not await self.redis.set("hn:refresh:" + digest, "used", nx=True, ex=2592000):
|
||||
raise HTTPException(409, "refresh already attempted; use returned token or reauthorize")
|
||||
try:
|
||||
result = await self.platform.refresh(body.refresh_token)
|
||||
except PlatformError:
|
||||
raise HTTPException(502, "refresh failed; reauthorize") from None
|
||||
return no_cache(JSONResponse(result))
|
||||
@@ -0,0 +1,89 @@
|
||||
import asyncio
|
||||
import json
|
||||
import time
|
||||
import httpx
|
||||
|
||||
|
||||
class PlatformError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class Feishu:
|
||||
def __init__(self, settings, transport=None):
|
||||
self.settings = settings
|
||||
self.http = httpx.AsyncClient(base_url=settings.feishu_api_base.rstrip("/"),
|
||||
timeout=15, follow_redirects=False, transport=transport)
|
||||
self._token = None
|
||||
self._expires = 0
|
||||
self._tenant_token = None
|
||||
self._tenant_expires = 0
|
||||
self._lock = asyncio.Lock()
|
||||
|
||||
async def close(self):
|
||||
await self.http.aclose()
|
||||
|
||||
async def _json(self, method, path, **kwargs):
|
||||
try:
|
||||
response = await self.http.request(method, path, **kwargs)
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
if data.get("code", 0) != 0:
|
||||
raise PlatformError("platform rejected request")
|
||||
return data
|
||||
except (httpx.HTTPError, ValueError, KeyError) as exc:
|
||||
# Never propagate upstream bodies or credentials to caller/logs.
|
||||
raise PlatformError("platform request failed") from None
|
||||
|
||||
async def app_token(self):
|
||||
async with self._lock:
|
||||
if self._token and self._expires > time.monotonic() + 1800:
|
||||
return self._token
|
||||
data = await self._json("POST", "/open-apis/auth/v3/app_access_token/internal",
|
||||
json={"app_id": self.settings.feishu_app_id,
|
||||
"app_secret": self.settings.feishu_app_secret})
|
||||
self._token = data["app_access_token"]
|
||||
self._expires = time.monotonic() + int(data.get("expire", 7200))
|
||||
return self._token
|
||||
|
||||
async def exchange(self, code):
|
||||
token = await self.app_token()
|
||||
data = await self._json("POST", "/open-apis/authen/v1/oidc/access_token",
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
json={"grant_type": "authorization_code", "code": code})
|
||||
return self.normalize(data["data"])
|
||||
|
||||
async def tenant_token(self):
|
||||
async with self._lock:
|
||||
if self._tenant_token and self._tenant_expires > time.monotonic() + 1800:
|
||||
return self._tenant_token
|
||||
data = await self._json("POST", "/open-apis/auth/v3/tenant_access_token/internal",
|
||||
json={"app_id": self.settings.feishu_app_id,
|
||||
"app_secret": self.settings.feishu_app_secret})
|
||||
self._tenant_token = data["tenant_access_token"]
|
||||
self._tenant_expires = time.monotonic() + int(data.get("expire", 7200))
|
||||
return self._tenant_token
|
||||
|
||||
async def refresh(self, refresh_token):
|
||||
token = await self.app_token()
|
||||
data = await self._json("POST", "/open-apis/authen/v1/oidc/refresh_access_token",
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
json={"grant_type": "refresh_token", "refresh_token": refresh_token})
|
||||
return self.normalize(data["data"])
|
||||
|
||||
@staticmethod
|
||||
def normalize(data):
|
||||
return {"user_access_token": data["access_token"], "refresh_token": data.get("refresh_token", ""),
|
||||
"expires_in": data.get("expires_in", data.get("expire", 0)),
|
||||
"refresh_expires_in": data.get("refresh_expires_in", 0), "open_id": data["open_id"]}
|
||||
|
||||
async def user_info(self, token):
|
||||
data = await self._json("GET", "/open-apis/authen/v1/user_info",
|
||||
headers={"Authorization": f"Bearer {token}"})
|
||||
return data["data"]
|
||||
|
||||
async def reply(self, message_id, text):
|
||||
# Reply to the original message only: no caller-controlled recipient.
|
||||
token = await self.tenant_token()
|
||||
await self._json("POST", f"/open-apis/im/v1/messages/{message_id}/reply",
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
json={"msg_type": "text", "content": json.dumps({"text": text}, ensure_ascii=False)})
|
||||
@@ -0,0 +1,167 @@
|
||||
import asyncio
|
||||
import contextlib
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
|
||||
from redis.asyncio import Redis
|
||||
from redis.exceptions import WatchError
|
||||
|
||||
from .config import Settings
|
||||
from .crypto import fingerprint, raw_public, verified, verify_device
|
||||
|
||||
|
||||
async def compare_delete(redis, key, expected):
|
||||
async with redis.pipeline() as pipe:
|
||||
try:
|
||||
await pipe.watch(key)
|
||||
if await pipe.get(key) != expected:
|
||||
return False
|
||||
pipe.multi()
|
||||
pipe.delete(key)
|
||||
await pipe.execute()
|
||||
return True
|
||||
except WatchError:
|
||||
return False
|
||||
|
||||
|
||||
async def compare_expire(redis, key, expected, ttl):
|
||||
async with redis.pipeline() as pipe:
|
||||
try:
|
||||
await pipe.watch(key)
|
||||
if await pipe.get(key) != expected:
|
||||
return False
|
||||
pipe.multi()
|
||||
pipe.expire(key, ttl)
|
||||
await pipe.execute()
|
||||
return True
|
||||
except WatchError:
|
||||
return False
|
||||
|
||||
|
||||
def create_app(settings=None, redis=None):
|
||||
s = settings or Settings(role="router")
|
||||
r = redis or Redis.from_url(s.redis_url, decode_responses=True)
|
||||
ca = s.ca_cert.read_bytes()
|
||||
active = set()
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app):
|
||||
await r.ping()
|
||||
yield
|
||||
if redis is None:
|
||||
await r.aclose()
|
||||
|
||||
app = FastAPI(title="Hainuo B2 router", lifespan=lifespan, docs_url=None, redoc_url=None)
|
||||
app.state.redis = r
|
||||
|
||||
@app.get("/health")
|
||||
async def health():
|
||||
return {"status": "alive", "role": "router"}
|
||||
|
||||
@app.get("/ready")
|
||||
async def ready():
|
||||
await r.ping()
|
||||
return {"status": "ready", "connections": len(active)}
|
||||
|
||||
@app.websocket("/device/ws")
|
||||
async def device(ws: WebSocket):
|
||||
from .common import rate_limit
|
||||
from fastapi import HTTPException
|
||||
await ws.accept()
|
||||
if len(active) >= s.max_connections:
|
||||
await ws.close(1013)
|
||||
return
|
||||
ip = ws.client.host if ws.client else "unknown"
|
||||
try:
|
||||
await rate_limit(r, "ws:" + ip, 30)
|
||||
except HTTPException:
|
||||
await ws.close(1008)
|
||||
return
|
||||
challenge = secrets.token_urlsafe(32)
|
||||
host = session = presence = None
|
||||
tasks = []
|
||||
pub = None
|
||||
try:
|
||||
await ws.send_json({"type": "challenge", "challenge": challenge})
|
||||
hello = await asyncio.wait_for(ws.receive_json(), timeout=10)
|
||||
if len(json.dumps(hello)) > 20000:
|
||||
raise ValueError("oversized hello")
|
||||
host = hello["host_id"]
|
||||
if not isinstance(host, str) or len(host) != 32 or any(c not in "0123456789abcdef" for c in host):
|
||||
raise ValueError("invalid host")
|
||||
public = verify_device(hello["cert"], ca, host)
|
||||
proof = verified(hello["proof"], public)
|
||||
if proof["challenge"] != challenge or proof["host_id"] != host or abs(time.time() - proof["ts"]) > 90:
|
||||
raise ValueError("invalid proof")
|
||||
if len(proof["kx"]) > 64 or len(proof["session_id"]) > 64:
|
||||
raise ValueError("invalid session")
|
||||
fp = fingerprint(hello["cert"])
|
||||
if await r.get("hn:device:" + host) != fp or await r.exists("hn:revoked:" + host):
|
||||
raise ValueError("unregistered/revoked")
|
||||
session = proof["session_id"]
|
||||
presence = json.dumps({"cert": hello["cert"], "proof": hello["proof"], "challenge": challenge})
|
||||
if not await r.set("hn:online:" + host, presence, nx=True, ex=30):
|
||||
raise ValueError("already connected")
|
||||
active.add(session)
|
||||
pub = r.pubsub()
|
||||
await pub.subscribe("hn:down:" + host, "hn:kill:" + host)
|
||||
await ws.send_json({"type": "connected", "session_id": session})
|
||||
|
||||
async def downstream():
|
||||
async for msg in pub.listen():
|
||||
if msg["type"] != "message":
|
||||
continue
|
||||
if msg["channel"] == "hn:kill:" + host:
|
||||
await ws.close(1008)
|
||||
return
|
||||
await ws.send_text(msg["data"])
|
||||
|
||||
async def heartbeat():
|
||||
while True:
|
||||
await asyncio.sleep(8)
|
||||
if await r.exists("hn:revoked:" + host) or not await compare_expire(r, "hn:online:" + host, presence, 30):
|
||||
await ws.close(1008)
|
||||
return
|
||||
|
||||
async def upstream():
|
||||
while True:
|
||||
text = await ws.receive_text()
|
||||
if len(text.encode()) > s.max_body:
|
||||
raise ValueError("oversized frame")
|
||||
data = json.loads(text)
|
||||
if data.get("type") == "ping":
|
||||
continue
|
||||
await rate_limit(r, "ws:reply:" + host, 120)
|
||||
turn = data.get("turn_id", "")
|
||||
if data.get("type") != "reply" or await r.get(f"hn:inflight:{host}:{turn}") != session:
|
||||
raise ValueError("unsolicited reply")
|
||||
envelope = data["envelope"]
|
||||
verified(envelope, public)
|
||||
if envelope["host_id"] != host or envelope["session_id"] != session:
|
||||
raise ValueError("wrong reply destination")
|
||||
await r.publish("hn:replies", json.dumps(data))
|
||||
|
||||
tasks = [asyncio.create_task(x()) for x in (downstream, heartbeat, upstream)]
|
||||
done, _ = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
|
||||
for task in done:
|
||||
task.result()
|
||||
except (WebSocketDisconnect, asyncio.TimeoutError, ValueError, KeyError, TypeError):
|
||||
with contextlib.suppress(Exception):
|
||||
await ws.close(1008)
|
||||
except Exception:
|
||||
with contextlib.suppress(Exception):
|
||||
await ws.close(1011)
|
||||
finally:
|
||||
for task in tasks:
|
||||
task.cancel()
|
||||
await asyncio.gather(*tasks, return_exceptions=True)
|
||||
if pub:
|
||||
await pub.aclose()
|
||||
if presence:
|
||||
await compare_delete(r, "hn:online:" + host, presence)
|
||||
active.discard(session)
|
||||
|
||||
return app
|
||||
@@ -0,0 +1,97 @@
|
||||
"""Connector-owned persistent metadata. Never stores message/file/token bodies."""
|
||||
import sqlite3
|
||||
import time
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
|
||||
INTEGRITY_ERRORS = (sqlite3.IntegrityError, psycopg.IntegrityError)
|
||||
|
||||
|
||||
class Postgres:
|
||||
def __init__(self, url):
|
||||
self.url = url
|
||||
self.conn = psycopg.connect(url, autocommit=True, row_factory=dict_row)
|
||||
self.transaction = None
|
||||
|
||||
def execute(self, sql, params=()):
|
||||
if self.conn.closed or self.conn.broken:
|
||||
self.conn = psycopg.connect(self.url, autocommit=True, row_factory=dict_row)
|
||||
return self.conn.execute(sql.replace("?", "%s"), params)
|
||||
|
||||
def __enter__(self):
|
||||
self.transaction = self.conn.transaction()
|
||||
self.transaction.__enter__()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
return self.transaction.__exit__(*args)
|
||||
|
||||
def close(self):
|
||||
self.conn.close()
|
||||
|
||||
|
||||
class Store:
|
||||
def __init__(self, path, database_url=""):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
schema = """
|
||||
CREATE TABLE IF NOT EXISTS devices(
|
||||
host_id TEXT PRIMARY KEY, cert TEXT NOT NULL, fingerprint TEXT NOT NULL,
|
||||
owner TEXT UNIQUE, revoked INTEGER NOT NULL DEFAULT 0);
|
||||
CREATE TABLE IF NOT EXISTS turns(
|
||||
turn_id TEXT PRIMARY KEY, owner TEXT NOT NULL, host_id TEXT NOT NULL,
|
||||
status TEXT NOT NULL, created DOUBLE PRECISION NOT NULL);
|
||||
CREATE TABLE IF NOT EXISTS audit(
|
||||
id INTEGER PRIMARY KEY, ts DOUBLE PRECISION NOT NULL, actor TEXT NOT NULL,
|
||||
action TEXT NOT NULL, resource TEXT NOT NULL, result TEXT NOT NULL);
|
||||
"""
|
||||
if database_url:
|
||||
self.db = Postgres(database_url)
|
||||
self.db.conn.execute(schema.replace("id INTEGER PRIMARY KEY", "id BIGSERIAL PRIMARY KEY"))
|
||||
else:
|
||||
self.db = sqlite3.connect(path, check_same_thread=False)
|
||||
self.db.row_factory = sqlite3.Row
|
||||
self.db.executescript("PRAGMA journal_mode=WAL;" + schema)
|
||||
|
||||
def device(self, host):
|
||||
row = self.db.execute("SELECT * FROM devices WHERE host_id=?", (host,)).fetchone()
|
||||
return dict(row) if row else None
|
||||
|
||||
def by_owner(self, owner):
|
||||
row = self.db.execute("SELECT * FROM devices WHERE owner=? AND revoked=0", (owner,)).fetchone()
|
||||
return dict(row) if row else None
|
||||
|
||||
def add_device(self, host, cert, fp):
|
||||
with self.db:
|
||||
self.db.execute("INSERT INTO devices(host_id,cert,fingerprint) VALUES(?,?,?)", (host, cert, fp))
|
||||
|
||||
def bind(self, host, owner):
|
||||
with self.db:
|
||||
# Conditional update also protects against two connectors racing for the same device.
|
||||
count = self.db.execute("UPDATE devices SET owner=? WHERE host_id=? AND owner IS NULL AND revoked=0", (owner, host)).rowcount
|
||||
if count != 1:
|
||||
raise ValueError("device unavailable or already bound")
|
||||
|
||||
def unbind(self, owner):
|
||||
with self.db:
|
||||
self.db.execute("UPDATE devices SET owner=NULL WHERE owner=?", (owner,))
|
||||
|
||||
def revoke(self, host):
|
||||
with self.db:
|
||||
self.db.execute("UPDATE devices SET revoked=1 WHERE host_id=?", (host,))
|
||||
|
||||
def begin_turn(self, turn, owner, host):
|
||||
with self.db:
|
||||
return self.db.execute("INSERT INTO turns VALUES(?,?,?,?,?) ON CONFLICT(turn_id) DO NOTHING",
|
||||
(turn, owner, host, "inflight", time.time())).rowcount == 1
|
||||
|
||||
def finish(self, turn, status):
|
||||
with self.db:
|
||||
self.db.execute("UPDATE turns SET status=? WHERE turn_id=?", (status, turn))
|
||||
|
||||
def audit(self, actor, action, resource, result):
|
||||
with self.db:
|
||||
self.db.execute("INSERT INTO audit(ts,actor,action,resource,result) VALUES(?,?,?,?,?)",
|
||||
(time.time(), actor, action, resource, result))
|
||||
|
||||
def close(self):
|
||||
self.db.close()
|
||||
@@ -0,0 +1,117 @@
|
||||
"use strict";
|
||||
const byId = id => document.getElementById(id);
|
||||
const statusNode = byId("status");
|
||||
let sending = false;
|
||||
let loggedIn = false;
|
||||
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
|
||||
function note(text) { statusNode.textContent = text; }
|
||||
function addMessage(text, role) {
|
||||
const item = document.createElement("div");
|
||||
item.className = "message " + role;
|
||||
item.textContent = text;
|
||||
byId("messages").appendChild(item);
|
||||
item.scrollIntoView({block:"nearest"});
|
||||
}
|
||||
async function refresh() {
|
||||
try {
|
||||
const response = await fetch("/web/session", {cache:"no-store", credentials:"same-origin"});
|
||||
if (!response.ok) {
|
||||
loggedIn = false;
|
||||
byId("pair-panel").hidden = false;
|
||||
byId("chat-panel").hidden = true;
|
||||
note(response.status === 401 ? "请使用PC上的一次性配对码连接。" : "会话服务暂不可用。");
|
||||
return;
|
||||
}
|
||||
const data = await response.json();
|
||||
loggedIn = true;
|
||||
byId("pair-panel").hidden = true;
|
||||
byId("chat-panel").hidden = false;
|
||||
byId("device-state").textContent = data.online ? "你的电脑已在线" : "你的电脑当前离线";
|
||||
if (!sending) note(data.online ? "已连接本人设备,可以开始对话。" : "请在PC启动桥接端,随后再发送消息。");
|
||||
} catch (_) { if (!sending) note("网络连接失败,请检查到中继的连接。"); }
|
||||
}
|
||||
byId("pair-form").addEventListener("submit", async event => {
|
||||
event.preventDefault();
|
||||
byId("pair-button").disabled = true;
|
||||
try {
|
||||
const response = await fetch("/web/claim", {method:"POST", credentials:"same-origin",
|
||||
headers:{"Content-Type":"application/json"}, body:JSON.stringify({code:byId("code").value.trim()})});
|
||||
if (!response.ok) throw new Error(response.status === 404 ? "配对码已过期或已使用,请在PC重新生成。" : "配对失败,请确认地址、配对码和设备绑定。");
|
||||
byId("code").value = "";
|
||||
await refresh();
|
||||
} catch (error) { note(error.message); }
|
||||
finally { byId("pair-button").disabled = false; }
|
||||
});
|
||||
byId("chat-form").addEventListener("submit", async event => {
|
||||
event.preventDefault();
|
||||
if (sending || !loggedIn) return;
|
||||
const text = byId("message").value.trim();
|
||||
if (!text) return;
|
||||
const bytes = new Uint8Array(16);
|
||||
crypto.getRandomValues(bytes);
|
||||
const requestId = Array.from(bytes, n => n.toString(16).padStart(2,"0")).join("");
|
||||
sending = true;
|
||||
byId("send").disabled = true;
|
||||
byId("logout").disabled = true;
|
||||
addMessage(text, "user");
|
||||
byId("message").value = "";
|
||||
note("正在等待你的电脑和模型返回结果…");
|
||||
const controller = new AbortController();
|
||||
const timer = setTimeout(() => controller.abort(), 200000);
|
||||
try {
|
||||
const response = await fetch("/web/chat", {method:"POST", credentials:"same-origin", signal:controller.signal,
|
||||
headers:{"Content-Type":"application/json"}, body:JSON.stringify({text, request_id:requestId})});
|
||||
if (!response.ok) throw new Error(response.status === 401 ? "网页会话已失效,请重新配对。" : "请求失败,HTTP " + response.status + "。请核查执行状态后再决定是否重发。");
|
||||
const data = await response.json();
|
||||
addMessage(data.result || "未收到文本结果。", data.status === "completed" ? "assistant" : "notice");
|
||||
note("请求状态:" + data.status);
|
||||
} catch (error) {
|
||||
addMessage(error.name === "AbortError" ? "等待超时,执行状态未知。系统没有自动重发。" : error.message, "notice");
|
||||
note("请求ID:" + requestId + "。请保留此ID排查,勿盲目重发。");
|
||||
} finally {
|
||||
clearTimeout(timer); sending = false;
|
||||
byId("send").disabled = false; byId("logout").disabled = false;
|
||||
}
|
||||
});
|
||||
byId("logout").addEventListener("click", async () => {
|
||||
try {
|
||||
const response = await fetch("/web/logout", {method:"POST", credentials:"same-origin"});
|
||||
if (!response.ok) throw new Error("退出失败,请稍后重试。");
|
||||
byId("messages").replaceChildren();
|
||||
await refresh();
|
||||
} catch (error) { note(error.message); }
|
||||
});
|
||||
byId("login").addEventListener("click", async () => {
|
||||
const popup = window.open("about:blank", "hainuo_authorize");
|
||||
if (!popup) { note("请允许打开授权窗口。"); return; }
|
||||
popup.opener = null;
|
||||
byId("login").disabled = true;
|
||||
try {
|
||||
const started = await fetch("/oauth/start", {method:"POST", headers:{"Content-Type":"application/json"}, body:"{}", cache:"no-store"});
|
||||
if (!started.ok) throw new Error("海能Work授权尚未配置,可先使用PC配对码。");
|
||||
const transaction = await started.json();
|
||||
const url = new URL(transaction.authorization_url);
|
||||
if (url.protocol !== "https:") throw new Error("授权地址必须使用HTTPS。");
|
||||
popup.location = url.href;
|
||||
note("请在授权窗口完成登录。");
|
||||
const until = Date.now() + transaction.expires_in * 1000;
|
||||
let token;
|
||||
while (Date.now() < until) {
|
||||
await sleep(2000);
|
||||
const response = await fetch("/oauth/claim?state=" + encodeURIComponent(transaction.state), {
|
||||
headers:{"X-OAuth-Claim-Secret":transaction.claim_secret}, cache:"no-store"});
|
||||
if (response.status === 202) continue;
|
||||
if (!response.ok) throw new Error("授权已失效,请重新开始。");
|
||||
token = (await response.json()).user_access_token;
|
||||
break;
|
||||
}
|
||||
if (!token) throw new Error("等待授权超时。");
|
||||
const response = await fetch("/web/platform-session", {method:"POST", headers:{Authorization:"Bearer " + token}});
|
||||
token = null;
|
||||
if (!response.ok) throw new Error("请先在海能Work完成本人设备绑定。");
|
||||
await refresh();
|
||||
} catch (error) { note(error.message); try { popup.close(); } catch (_) {} }
|
||||
finally { byId("login").disabled = false; }
|
||||
});
|
||||
refresh();
|
||||
setInterval(() => { if (!sending) refresh(); }, 15000);
|
||||
@@ -0,0 +1,15 @@
|
||||
<!doctype html>
|
||||
<html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
||||
<title>海诺 · 我的工作电脑</title><link rel="stylesheet" href="/assets/style.css"><script defer src="/assets/app.js"></script></head>
|
||||
<body><main><div class="mark">海诺 HAINUO <span class="badge">试点 · 纯文本</span></div>
|
||||
<h1>连接你的<br>工作电脑。</h1><p class="intro">电脑上的助手,随时与你对话。先完成本人设备配对,再开始工作。</p>
|
||||
<section class="card" id="pair-panel"><span class="step">01 / 连接本人设备</span><h2>输入电脑上的配对码</h2>
|
||||
<p>在已绑定的PC运行网页配对命令,将生成的一次性配对码填在这里。有效期两分钟,请勿转发。</p>
|
||||
<form id="pair-form"><label for="code">网页配对码</label><input id="code" name="code" autocomplete="off" spellcheck="false" required maxlength="128" placeholder="粘贴PC生成的配对码"><button type="submit" id="pair-button">连接我的电脑 <span>↗</span></button></form>
|
||||
<details><summary>使用海能Work授权</summary><p>需要管理员已配置平台应用与OAuth回调。</p><button id="login" type="button">通过海能Work登录</button></details></section>
|
||||
<section class="card" id="chat-panel" hidden><div class="chat-head"><div><span class="step">02 / 本人设备会话</span><h2 id="device-state">正在连接</h2></div><button id="logout" type="button" class="secondary">解除网页登录</button></div>
|
||||
<p class="hint">当前为纯文本推理。可发送“17加25是多少”,或使用 /主机名 验证目标电脑。暂不开放文件操作。</p>
|
||||
<div id="messages" role="log" aria-live="polite"></div><form id="chat-form"><label for="message">给你的助手发消息</label><textarea id="message" rows="3" maxlength="8000" placeholder="描述你的问题…" required></textarea><button id="send" type="submit">发送消息 <span>↑</span></button></form></section>
|
||||
<p id="status" role="status" aria-live="polite">正在检查网页会话…</p>
|
||||
<footer>PC需保持开机、联网,并运行原生API和桥接端。试点网页由中继在内存中转发正文,不保存聊天记录;当前页关闭后消息不保留。</footer>
|
||||
</main></body></html>
|
||||
@@ -0,0 +1,3 @@
|
||||
:root{color-scheme:light;font-family:system-ui,-apple-system,"Segoe UI","Microsoft YaHei",sans-serif;color:#17372c;background:#f2f4ed}*{box-sizing:border-box}body{margin:0}main{max-width:820px;margin:0 auto;padding:60px 26px}.mark{font-size:13px;letter-spacing:.16em;color:#557764;font-weight:700}h1{font-size:clamp(42px,8vw,70px);letter-spacing:-.05em;line-height:1.12;font-weight:650;margin:40px 0 22px}.intro{font-size:17px;line-height:1.8;color:#56675a;max-width:520px}.card{background:#fff;border:1px solid #dbe3d8;border-radius:20px;padding:30px;margin:40px 0 24px;box-shadow:0 12px 44px #18372c06}.step{font-size:12px;letter-spacing:.1em;color:#6d806c}h2{font-size:24px;margin:16px 0}.card p{line-height:1.8;color:#5b6c60}button{background:#214e3a;color:white;border:0;border-radius:10px;font:inherit;font-weight:600;padding:16px 20px;width:100%;text-align:left;cursor:pointer;margin-top:16px}button span{float:right}button:disabled{opacity:.5;cursor:wait}button:focus-visible,a:focus-visible{outline:3px solid #d0a349;outline-offset:4px}#status{font-size:13px;margin-bottom:0}#open{display:block;margin-top:22px;color:#214e3a;font-weight:600}#open[hidden]{display:none}footer{color:#768373;font-size:12px;line-height:1.8}@media(max-width:480px){main{padding-top:36px}.card{padding:22px}h1{margin-top:28px}}
|
||||
|
||||
[hidden]{display:none!important}.badge{float:right;font-size:11px;letter-spacing:0;background:#e4ebdf;border-radius:20px;padding:6px 10px}label{display:block;font-size:13px;color:#526c5b;margin:12px 0 8px}input,textarea{font:inherit;width:100%;border:1px solid #ccd8ce;border-radius:10px;padding:14px;color:#17372c;background:#fafcf8;resize:vertical}input:focus,textarea:focus{outline:2px solid #6c987b;outline-offset:2px}details{margin-top:24px;font-size:13px;color:#587561}summary{cursor:pointer}.chat-head{display:flex;align-items:center;justify-content:space-between;gap:20px}.secondary{width:auto;background:#edf2e9;color:#31523f;padding:9px 12px;font-size:12px;margin:0}.hint{font-size:13px}#messages{display:flex;flex-direction:column;gap:12px;margin:22px 0;max-height:420px;overflow:auto}.message{padding:14px 16px;border-radius:12px;line-height:1.8;white-space:pre-wrap;overflow-wrap:anywhere;font-size:15px}.message.user{background:#e5eee2;margin-left:36px}.message.assistant{background:#f2f5ef;margin-right:24px}.message.notice{background:#fbf4e5;color:#735c2e}#status{font-size:13px;color:#5f745f;line-height:1.8}#chat-panel h2{font-size:20px}footer{max-width:640px}
|
||||
@@ -0,0 +1,183 @@
|
||||
"""Pilot H5 pairing and conversation. Credentials never appear in URLs."""
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from .common import no_cache, peer, rate_limit
|
||||
from .crypto import sign, verified, verify_device
|
||||
from .platform import PlatformError
|
||||
|
||||
COOKIE = "hn_web_session"
|
||||
|
||||
|
||||
def digest(value):
|
||||
return hashlib.sha256(value.encode()).hexdigest()
|
||||
|
||||
|
||||
def origin_tuple(value):
|
||||
try:
|
||||
parts = urlsplit(value)
|
||||
if parts.scheme not in {"https", "http"} or not parts.hostname or parts.username or parts.password:
|
||||
return None
|
||||
return parts.scheme, parts.hostname.lower(), parts.port or (443 if parts.scheme == "https" else 80)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
class PairProof(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
proof: dict
|
||||
|
||||
|
||||
class Claim(BaseModel):
|
||||
code: str = Field(min_length=12, max_length=128)
|
||||
|
||||
|
||||
class Chat(BaseModel):
|
||||
text: str = Field(min_length=1, max_length=8000)
|
||||
request_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
|
||||
|
||||
class WebSessions:
|
||||
def __init__(self, settings, redis, store, broker, platform):
|
||||
self.s, self.r, self.store, self.broker, self.platform = settings, redis, store, broker, platform
|
||||
self.router = APIRouter()
|
||||
for path, method, handler in [
|
||||
("/device/web-pair", "POST", self.device_pair),
|
||||
("/web/claim", "POST", self.claim),
|
||||
("/web/session", "GET", self.session),
|
||||
("/web/platform-session", "POST", self.platform_login),
|
||||
("/web/chat", "POST", self.chat),
|
||||
("/web/logout", "POST", self.logout),
|
||||
]:
|
||||
self.router.add_api_route(path, handler, methods=[method])
|
||||
|
||||
def check_origin(self, request):
|
||||
actual = origin_tuple(request.headers.get("Origin", ""))
|
||||
if not actual or actual != origin_tuple(self.s.public_url):
|
||||
raise HTTPException(403, "same-origin browser request required")
|
||||
|
||||
async def valid_device(self, record):
|
||||
device = self.store.device(record["host_id"])
|
||||
if (not device or device["revoked"] or device["owner"] != record["owner"]
|
||||
or device["fingerprint"] != record["fingerprint"]):
|
||||
raise HTTPException(401, "device binding changed; pair again")
|
||||
generation = await self.r.get("hn:web-generation:" + record["host_id"]) or "0"
|
||||
if record.get("generation") != generation:
|
||||
raise HTTPException(401, "device binding changed; pair again")
|
||||
return device
|
||||
|
||||
async def device_pair(self, body: PairProof, request: Request):
|
||||
await rate_limit(self.r, "web-pair-ip:" + peer(request), 20)
|
||||
device = self.store.device(body.host_id)
|
||||
if not device or device["revoked"] or not device["owner"]:
|
||||
raise HTTPException(403, "active bound device required")
|
||||
try:
|
||||
key = verify_device(device["cert"], self.s.ca_cert.read_bytes(), body.host_id)
|
||||
proof = verified(body.proof, key)
|
||||
if (proof["host_id"] != body.host_id or proof["owner"] != device["owner"]
|
||||
or proof["purpose"] != "h5-pair-v1" or abs(time.time() - proof["ts"]) > 90
|
||||
or not isinstance(proof["nonce"], str) or len(proof["nonce"]) != 32):
|
||||
raise ValueError("invalid proof")
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid device proof") from None
|
||||
replay = "hn:web-pair-proof:" + digest(body.host_id + proof["nonce"])
|
||||
if not await self.r.set(replay, "used", nx=True, ex=180):
|
||||
raise HTTPException(409, "pairing request already used")
|
||||
await rate_limit(self.r, "web-pair-device:" + body.host_id, 5)
|
||||
code = secrets.token_urlsafe(18)
|
||||
record = {"host_id": body.host_id, "owner": device["owner"], "fingerprint": device["fingerprint"],
|
||||
"generation": await self.r.get("hn:web-generation:" + body.host_id) or "0"}
|
||||
await self.r.set("hn:web-code:" + digest(code), json.dumps(record), ex=120)
|
||||
self.store.audit(device["owner"], "web_pair_issued", body.host_id, "success")
|
||||
return no_cache(JSONResponse(sign({"host_id": body.host_id, "code": code, "expires_in": 120,
|
||||
"url": self.s.public_url.rstrip("/") + "/h5"}, self.broker.signer)))
|
||||
|
||||
async def new_session(self, record):
|
||||
token = secrets.token_urlsafe(32)
|
||||
record = {k: record[k] for k in ("host_id", "owner", "fingerprint", "generation")}
|
||||
await self.r.set("hn:web-session:" + digest(token), json.dumps(record), ex=1800)
|
||||
response = no_cache(JSONResponse({"status": "paired", "host_id": record["host_id"], "expires_in": 1800}))
|
||||
response.set_cookie(COOKIE, token, max_age=1800, secure=True, httponly=True, samesite="strict", path="/")
|
||||
return response
|
||||
|
||||
async def claim(self, body: Claim, request: Request):
|
||||
self.check_origin(request)
|
||||
await rate_limit(self.r, "web-claim:" + peer(request), 20)
|
||||
key = "hn:web-code:" + digest(body.code.strip())
|
||||
encoded = await self.r.get(key)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "code expired or consumed")
|
||||
await self.valid_device(json.loads(encoded))
|
||||
encoded = await self.r.getdel(key)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "code already consumed")
|
||||
record = json.loads(encoded)
|
||||
await self.valid_device(record)
|
||||
self.store.audit(record["owner"], "web_pair_claimed", record["host_id"], "success")
|
||||
return await self.new_session(record)
|
||||
|
||||
async def authenticated(self, request):
|
||||
token = request.cookies.get(COOKIE, "")
|
||||
if not token or len(token) > 128:
|
||||
raise HTTPException(401, "pair this browser first")
|
||||
encoded = await self.r.get("hn:web-session:" + digest(token))
|
||||
if not encoded:
|
||||
raise HTTPException(401, "browser session expired")
|
||||
record = json.loads(encoded)
|
||||
await self.valid_device(record)
|
||||
return record
|
||||
|
||||
async def session(self, request: Request):
|
||||
record = await self.authenticated(request)
|
||||
return no_cache(JSONResponse({"authenticated": True, "host_id": record["host_id"],
|
||||
"online": bool(await self.r.exists("hn:online:" + record["host_id"])),
|
||||
"mode": "pilot-text-only", "relay_sees_content": True}))
|
||||
|
||||
async def platform_login(self, request: Request):
|
||||
self.check_origin(request)
|
||||
if not self.s.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
await rate_limit(self.r, "web-platform:" + peer(request), 20)
|
||||
auth = request.headers.get("Authorization", "")
|
||||
if not auth.startswith("Bearer ") or len(auth) > 8192:
|
||||
raise HTTPException(401, "user token required")
|
||||
try:
|
||||
info = await self.platform.user_info(auth[7:])
|
||||
except PlatformError:
|
||||
raise HTTPException(401, "invalid user token") from None
|
||||
device = self.store.by_owner(info["open_id"])
|
||||
if not device:
|
||||
raise HTTPException(404, "bind your device first")
|
||||
return await self.new_session({**device, "generation": await self.r.get("hn:web-generation:" + device["host_id"]) or "0"})
|
||||
|
||||
async def chat(self, body: Chat, request: Request):
|
||||
self.check_origin(request)
|
||||
record = await self.authenticated(request)
|
||||
await rate_limit(self.r, "web-chat:" + record["owner"], 20)
|
||||
text = body.text.strip()
|
||||
if not text:
|
||||
raise HTTPException(422, "empty message")
|
||||
# PC accepts only its bound owner and the existing IM read-only channel.
|
||||
if not (text == "/主机名" or text.startswith(("/回显 ", "/读取 ", "/助手 "))):
|
||||
text = "/助手 " + text
|
||||
turn = "web_" + digest(record["owner"] + "\0" + body.request_id)
|
||||
result = await self.broker.dispatch(record["owner"], text, turn)
|
||||
# Revoke/unbind during a long model call invalidates the browser immediately.
|
||||
await self.authenticated(request)
|
||||
return no_cache(JSONResponse(result))
|
||||
|
||||
async def logout(self, request: Request):
|
||||
self.check_origin(request)
|
||||
token = request.cookies.get(COOKIE, "")
|
||||
if token and len(token) <= 128:
|
||||
await self.r.delete("hn:web-session:" + digest(token))
|
||||
response = no_cache(JSONResponse({"status": "logged_out"}))
|
||||
response.delete_cookie(COOKIE, secure=True, httponly=True, samesite="strict", path="/")
|
||||
return response
|
||||
Reference in New Issue
Block a user