Import ECS deployed relay source and historical patches (2026-10-27)
This commit is contained in:
@@ -0,0 +1,10 @@
|
||||
FROM python:3.12-slim-bookworm
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1
|
||||
WORKDIR /app
|
||||
COPY wheelhouse /wheels
|
||||
COPY requirements.lock pyproject.toml ./
|
||||
COPY relay ./relay
|
||||
RUN pip install --no-index --find-links=/wheels --no-cache-dir -r requirements.lock && rm -rf /wheels
|
||||
RUN chmod -R a+rX /app
|
||||
USER 10001:10001
|
||||
ENTRYPOINT ["python", "-m", "relay.cli"]
|
||||
@@ -0,0 +1,6 @@
|
||||
services:
|
||||
connector:
|
||||
environment:
|
||||
HN_OAUTH_ENABLED: <REDACTED_LITERAL>
|
||||
HN_FEISHU_AUTHORIZE_URL: ${HN_FEISHU_AUTHORIZE_URL}
|
||||
HN_FEISHU_OAUTH_SCOPES: ${HN_FEISHU_OAUTH_SCOPES}
|
||||
@@ -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,293 @@
|
||||
"""Per-user Windows connection companion. No platform/application secrets."""
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import socket
|
||||
import ssl
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
import psutil
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
|
||||
from .crypto import load_private, load_public, pem_private, raw_public, sign, verified, verify_device
|
||||
from .windows_keys import protect
|
||||
|
||||
BASE = Path(__file__).resolve().parent.parent
|
||||
URL = "https://10.77.76.13"
|
||||
|
||||
|
||||
def save(path, value):
|
||||
temp = path.with_suffix(path.suffix + ".tmp")
|
||||
temp.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
os.replace(temp, path)
|
||||
|
||||
|
||||
def secure_directory(directory):
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
# SID avoids localized account names. Fail closed if ACL protection fails.
|
||||
result = subprocess.run(["whoami", "/user", "/fo", "csv", "/nh"], capture_output=True, text=True, check=True)
|
||||
import csv
|
||||
sid = list(csv.reader([result.stdout.strip()]))[0][1]
|
||||
subprocess.run(["icacls", str(directory), "/inheritance:r", "/grant:r", f"*{sid}:(OI)(CI)F", "*S-1-5-18:(OI)(CI)F"],
|
||||
capture_output=True, check=True, creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
|
||||
|
||||
def prepare(directory):
|
||||
secure_directory(directory)
|
||||
for name in ("server.pem", "ca.pem", "connector.pub"):
|
||||
target = directory / name
|
||||
if not target.exists():
|
||||
target.write_bytes((BASE / "trust" / name).read_bytes())
|
||||
if not (directory / "device.json").exists():
|
||||
if (directory / "device.key.dpapi").exists() or (directory / "device.key").exists():
|
||||
raise RuntimeError("发现不完整的设备身份,请保留目录并联系管理员恢复。")
|
||||
private = Ed25519PrivateKey.generate()
|
||||
(directory / "device.key.dpapi").write_bytes(protect(pem_private(private)))
|
||||
save(directory / "device.json", {"host_id": uuid.uuid4().hex, "owner": None})
|
||||
|
||||
|
||||
def tls(directory):
|
||||
return ssl.create_default_context(cafile=str(directory / "server.pem"))
|
||||
|
||||
|
||||
def import_existing(directory, source):
|
||||
"""Explicit migration; only public trust and this PC's identity, never app keys."""
|
||||
if source.resolve() == directory.resolve():
|
||||
raise ValueError("请选择旧设备目录。")
|
||||
if any((directory / name).exists() for name in ("device.json", "device.key.dpapi", "device.key")):
|
||||
raise RuntimeError("本目录已有设备身份。请使用已有身份继续,不能用导入覆盖。")
|
||||
config = json.loads((source / "device.json").read_text(encoding="utf-8-sig"))
|
||||
for name in ("server.pem", "ca.pem", "connector.pub"):
|
||||
if (source / name).read_bytes().strip() != (BASE / "trust" / name).read_bytes().strip():
|
||||
raise ValueError("旧设备的服务信任与本安装包不符,请联系管理员。")
|
||||
cert = (source / "device.pem").read_text(encoding="utf-8")
|
||||
public = verify_device(cert, (source / "ca.pem").read_bytes(), config["host_id"])
|
||||
private = load_private(source / "device.key")
|
||||
if raw_public(public) != raw_public(private.public_key()):
|
||||
raise ValueError("设备证书与本机私钥不匹配。")
|
||||
secure_directory(directory)
|
||||
for name in ("device.pem", "server.pem", "ca.pem", "connector.pub"):
|
||||
(directory / name).write_bytes((source / name).read_bytes())
|
||||
(directory / "device.key.dpapi").write_bytes(protect(pem_private(private)))
|
||||
save(directory / "device.json", config)
|
||||
# Preserve local replay journal using SQLite's consistent backup API.
|
||||
if (source / "journal.sqlite").is_file():
|
||||
import sqlite3
|
||||
with sqlite3.connect(source / "journal.sqlite") as original, sqlite3.connect(directory / "journal.sqlite") as target:
|
||||
original.backup(target)
|
||||
return {"message": "旧设备导入成功,Work绑定已保留。请先停止旧PowerShell桥接窗口,再点击启动连接。"}
|
||||
|
||||
|
||||
def enrollment(directory):
|
||||
prepare(directory)
|
||||
cfg = json.loads((directory / "device.json").read_text())
|
||||
if (directory / "device.pem").exists():
|
||||
verify_device((directory / "device.pem").read_text(), (directory / "ca.pem").read_bytes(), cfg["host_id"])
|
||||
return {"message": "设备已注册,可在Work获取绑定码后绑定。已有绑定可直接启动连接。"}
|
||||
with httpx.Client(verify=tls(directory), trust_env=False, timeout=15) as http:
|
||||
key = load_private(directory / "device.key")
|
||||
proof = sign({"host_id": cfg["host_id"], "purpose": "device-enroll-v1", "ts": int(time.time()), "nonce": secrets.token_hex(16)}, key)
|
||||
response = http.post(URL + "/device/register", json={"host_id": cfg["host_id"], "proof": proof,
|
||||
"public_key": key.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo).decode()})
|
||||
if response.status_code not in {200, 201}:
|
||||
raise RuntimeError("自动注册失败:HTTP " + str(response.status_code) + ";请确认ECS已安装1.067自动注册更新。")
|
||||
receipt = verified(response.json(), load_public(directory / "connector.pub"))
|
||||
if receipt.get("status") != "registered" or receipt["host_id"] != cfg["host_id"]:
|
||||
raise ValueError("注册回执身份不符")
|
||||
public = verify_device(receipt["cert"], (directory / "ca.pem").read_bytes(), cfg["host_id"])
|
||||
if raw_public(public) != raw_public(key.public_key()):
|
||||
raise ValueError("注册证书公钥不符")
|
||||
temp = directory / "device.pem.tmp"
|
||||
temp.write_text(receipt["cert"], encoding="utf-8")
|
||||
os.replace(temp, directory / "device.pem")
|
||||
(directory / "enrollment.json").unlink(missing_ok=True)
|
||||
return {"message": "设备已自动注册,无需管理员审批。请在Work获取绑定码,填写后点击绑定并连接。"}
|
||||
|
||||
|
||||
def managed_processes(directory):
|
||||
"""Only processes with our absolute entry path AND exact device directory."""
|
||||
state = directory / "processes.json"
|
||||
if not state.exists():
|
||||
return []
|
||||
result = []
|
||||
for item in json.loads(state.read_text()).get("processes", []):
|
||||
try:
|
||||
proc = psutil.Process(item["pid"])
|
||||
command = proc.cmdline()
|
||||
if (abs(proc.create_time() - item["created"]) < 0.1 and str(BASE / "entry.py") in command
|
||||
and str(directory) in command):
|
||||
result.append(proc)
|
||||
except psutil.Error:
|
||||
pass
|
||||
return result
|
||||
|
||||
|
||||
def stop(directory):
|
||||
procs = managed_processes(directory)
|
||||
# Supervisor owns and terminates only its own child handles in its finally block.
|
||||
(directory / "stop.flag").touch()
|
||||
_, alive = psutil.wait_procs(procs, timeout=8)
|
||||
for proc in alive:
|
||||
proc.terminate()
|
||||
return {"message": "已停止本安装包启动的连接进程。手工启动的旧桥接请在原窗口按Ctrl+C停止。"}
|
||||
|
||||
|
||||
def start(directory, root):
|
||||
from .process_lock import DeviceProcessLock
|
||||
with DeviceProcessLock(directory / "control"):
|
||||
return _start(directory, root)
|
||||
|
||||
|
||||
def _start(directory, root):
|
||||
cfg = json.loads((directory / "device.json").read_text())
|
||||
if not cfg.get("owner") or not (directory / "device.pem").exists():
|
||||
raise RuntimeError("请先完成设备准入和Work绑定。")
|
||||
if managed_processes(directory):
|
||||
return {"message": "连接进程已运行,请点击状态查看。"}
|
||||
(directory / "stop.flag").unlink(missing_ok=True)
|
||||
log = (directory / "bridge.log").open("a", encoding="utf-8")
|
||||
proc = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "supervise", "--directory", str(directory), "--root", str(root)],
|
||||
stdout=log, stderr=log, creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
log.close()
|
||||
save(directory / "processes.json", {"processes": [{"pid": proc.pid, "created": psutil.Process(proc.pid).create_time()}]})
|
||||
return {"message": "连接进程已启动;约30秒后点击状态,再到Work发送 /主机名 验证。"}
|
||||
|
||||
|
||||
def supervise(directory, root):
|
||||
from .process_lock import DeviceProcessLock
|
||||
lockdir = directory / "supervisor"
|
||||
with DeviceProcessLock(lockdir):
|
||||
children = []
|
||||
def record_children():
|
||||
processes = [psutil.Process(os.getpid())] + [psutil.Process(p.pid) for p in children if p.poll() is None]
|
||||
save(directory / "processes.json", {"processes": [{"pid": p.pid, "created": p.create_time()} for p in processes]})
|
||||
try:
|
||||
# Check local bind availability without an HTTP connection. Windows
|
||||
# filtering can time out connections to a closed port rather than
|
||||
# refuse them; that must not prevent starting our own listener.
|
||||
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as port_probe:
|
||||
try:
|
||||
if os.name == "nt":
|
||||
port_probe.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
|
||||
port_probe.bind(("127.0.0.1", 18643))
|
||||
except OSError:
|
||||
raise RuntimeError("原生API端口18643被占用或不允许绑定,请先检查旧连接。") from None
|
||||
native = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "native", "--directory", str(directory), "--root", str(root)])
|
||||
children.append(native)
|
||||
record_children()
|
||||
for _ in range(90):
|
||||
if (directory / "stop.flag").exists():
|
||||
return
|
||||
if native.poll() is not None:
|
||||
raise RuntimeError("本机原生API启动失败,请检查安装配置。")
|
||||
try:
|
||||
from .hainuo1065 import Hainuo1065Agent
|
||||
async def probe():
|
||||
agent = Hainuo1065Agent(directory / "hainuo-native.json")
|
||||
try:
|
||||
return await agent.probe()
|
||||
finally:
|
||||
await agent.close()
|
||||
asyncio.run(probe())
|
||||
break
|
||||
except Exception:
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise RuntimeError("本机原生API未就绪。")
|
||||
bridge = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "bridge", "--directory", str(directory), "--root", str(root)])
|
||||
children.append(bridge)
|
||||
record_children()
|
||||
while not (directory / "stop.flag").exists():
|
||||
if any(proc.poll() is not None for proc in children):
|
||||
raise RuntimeError("连接子进程已退出,请查看状态后重新启动。")
|
||||
time.sleep(0.5)
|
||||
finally:
|
||||
for proc in reversed(children):
|
||||
if proc.poll() is None:
|
||||
proc.terminate()
|
||||
try:
|
||||
proc.wait(timeout=5)
|
||||
except subprocess.TimeoutExpired:
|
||||
proc.kill()
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("action", choices=["authorize", "import", "enroll", "bind", "start", "stop", "status", "pair", "supervise", "native", "bridge"])
|
||||
parser.add_argument("--directory", type=Path, required=True)
|
||||
parser.add_argument("--root", type=Path, required=True)
|
||||
args = parser.parse_args()
|
||||
directory, root = args.directory.resolve(), args.root.resolve()
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
try:
|
||||
if args.action == "authorize":
|
||||
from .work_client import WorkClient
|
||||
client = WorkClient(directory)
|
||||
try:
|
||||
result = client.status()
|
||||
result["message"] += ("\n" + result["authorization_url"]) if result.get("authorization_url") else ""
|
||||
finally:
|
||||
client.close()
|
||||
elif args.action == "import":
|
||||
result = import_existing(directory, Path(sys.stdin.readline().strip()))
|
||||
elif args.action == "enroll":
|
||||
result = enrollment(directory)
|
||||
elif args.action == "bind":
|
||||
from .device import bind_device
|
||||
code = sys.stdin.readline().strip()
|
||||
if not code:
|
||||
raise ValueError("请填写Work机器人新生成的绑定码。")
|
||||
enrollment(directory)
|
||||
stop(directory)
|
||||
asyncio.run(bind_device(directory, URL, code, tls_verify=tls(directory)))
|
||||
result = start(directory, root)
|
||||
result["message"] = "Work绑定成功。" + result["message"]
|
||||
elif args.action == "start":
|
||||
result = start(directory, root)
|
||||
elif args.action == "stop":
|
||||
result = stop(directory)
|
||||
elif args.action == "pair":
|
||||
from .device import pair_browser
|
||||
receipt = asyncio.run(pair_browser(directory, URL, tls_verify=tls(directory)))
|
||||
result = {"message": "网页:" + receipt["url"] + "\n一次性配对码(120秒):" + receipt["code"]}
|
||||
elif args.action == "status":
|
||||
cfg = json.loads((directory / "device.json").read_text()) if (directory / "device.json").exists() else {}
|
||||
log = directory / "bridge.log"
|
||||
tail = log.read_bytes()[-6000:].decode("utf-8", errors="replace") if log.exists() else ""
|
||||
result = {"message": "设备:" + cfg.get("host_id", "未申请") + "\nWork身份:" + (cfg.get("owner") or "未绑定")
|
||||
+ "\n连接进程:" + ("运行中(请在Work发送 /主机名 确认当前链路)" if managed_processes(directory) else "未运行") + "\n" + tail[-2500:]}
|
||||
elif args.action == "supervise":
|
||||
return supervise(directory, root)
|
||||
elif args.action == "native":
|
||||
os.environ["HN_WORK_DEVICE_DIR"] = str(directory)
|
||||
import importlib.util
|
||||
spec = importlib.util.spec_from_file_location("native_companion", BASE / "hainuo_native_api.py")
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
module.enable_profile_tools(root, "hainuo")
|
||||
key = module.prepare_environment(root, "hainuo", 18643, directory / "hainuo-native.json", enable_tools=True)
|
||||
import logging
|
||||
logging.disable(logging.CRITICAL)
|
||||
return asyncio.run(module.serve_native(18643, key, enable_tools=True))
|
||||
else:
|
||||
from .device import run_device
|
||||
return asyncio.run(run_device(directory, "wss://10.77.76.13/device/ws", ssl_context=tls(directory), hainuo_config=directory / "hainuo-native.json"))
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
except Exception as error:
|
||||
# Native exception bodies may include URLs or secrets; emit bounded known messages only.
|
||||
message = str(error) if isinstance(error, (RuntimeError, ValueError)) else type(error).__name__ + ";请检查网络、证书、安装目录。"
|
||||
print(json.dumps({"message": message[:600], "error": True}, ensure_ascii=False))
|
||||
raise SystemExit(1) from None
|
||||
|
||||
|
||||
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,66 @@
|
||||
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_oauth_scopes: str = ""
|
||||
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
|
||||
enrollment_signer_url: str = ""
|
||||
|
||||
@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,506 @@
|
||||
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)
|
||||
oauth.store = store
|
||||
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)
|
||||
|
||||
from .enrollment import enrollment_router
|
||||
app.include_router(enrollment_router(s, r, store, broker.signer, admin))
|
||||
from .work_api import router as work_router
|
||||
app.include_router(work_router(s, r, store, f))
|
||||
|
||||
@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:
|
||||
instruction = text if text.startswith("/助手 ") else "/助手 " + text
|
||||
result = (await broker.dispatch(owner, instruction, "msg_" + hashlib.sha256(message_id.encode()).hexdigest()))["result"]
|
||||
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,140 @@
|
||||
"""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):
|
||||
protected = path.with_name(path.name + ".dpapi")
|
||||
if protected.is_file():
|
||||
from .windows_keys import unprotect
|
||||
data = unprotect(protected.read_bytes())
|
||||
else:
|
||||
data = path.read_bytes()
|
||||
return serialization.load_pem_private_key(data, 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,216 @@
|
||||
"""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, trust_env=False, 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, **kwargs):
|
||||
from .process_lock import DeviceProcessLock
|
||||
with DeviceProcessLock(directory):
|
||||
return await _run_device(directory, router_url, **kwargs)
|
||||
|
||||
|
||||
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")
|
||||
print("设备连接成功,已绑定本人海能Work身份。", flush=True)
|
||||
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 as error:
|
||||
if once:
|
||||
raise
|
||||
from websockets.exceptions import ConnectionClosed
|
||||
if isinstance(error, ConnectionClosed) and error.rcvd and error.rcvd.code == 1008:
|
||||
print("设备被中继拒绝:请检查是否有另一桥接进程、设备准入或证书状态。", flush=True)
|
||||
# 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,178 @@
|
||||
"""Device registration with key possession proof; Work binding is separate."""
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
import httpx
|
||||
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from pydantic import BaseModel, Field
|
||||
from .common import no_cache, peer, rate_limit
|
||||
from .crypto import verified, sign, raw_public, verify_device, fingerprint
|
||||
from .web_session import digest
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
|
||||
def validate_enrollment(body):
|
||||
try:
|
||||
key = serialization.load_pem_public_key(body.public_key.encode())
|
||||
if not isinstance(key, Ed25519PublicKey):
|
||||
raise ValueError()
|
||||
proof = verified(body.proof, key)
|
||||
if (proof["host_id"] != body.host_id or proof["purpose"] != "device-enroll-v1"
|
||||
or abs(time.time() - proof["ts"]) > 90 or len(proof["nonce"]) != 32):
|
||||
raise ValueError()
|
||||
return key
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid enrollment proof") from None
|
||||
|
||||
|
||||
async def request_certificate(settings, body):
|
||||
async with httpx.AsyncClient(trust_env=False, timeout=15, follow_redirects=False) as http:
|
||||
response = await http.post(settings.enrollment_signer_url.rstrip("/") + "/issue",
|
||||
headers={"X-Internal-Secret": settings.internal_secret},
|
||||
json=body.model_dump())
|
||||
response.raise_for_status()
|
||||
return response.json()["cert"]
|
||||
|
||||
|
||||
class EnrollmentRequest(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
public_key: str = Field(max_length=1024)
|
||||
proof: dict
|
||||
|
||||
|
||||
class EnrollmentApproval(BaseModel):
|
||||
cert: str = Field(max_length=10000)
|
||||
|
||||
|
||||
def enrollment_router(settings, redis, store, signer, admin):
|
||||
router = APIRouter()
|
||||
|
||||
@router.post("/device/register")
|
||||
async def automatic_registration(body: EnrollmentRequest, request: Request):
|
||||
# No human approval: eligibility follows intranet access plus Work app scope.
|
||||
# Proof/TLS/limits protect identity and resources, and do not add user approval.
|
||||
await rate_limit(redis, "auto-register-ip:" + peer(request), 120)
|
||||
key = validate_enrollment(body)
|
||||
await rate_limit(redis, "auto-register-host:" + body.host_id, 30)
|
||||
existing = store.device(body.host_id)
|
||||
|
||||
def check_existing(device):
|
||||
if device["revoked"]:
|
||||
raise HTTPException(403, "device revoked")
|
||||
try:
|
||||
registered = verify_device(device["cert"], settings.ca_cert.read_bytes(), body.host_id)
|
||||
if raw_public(registered) != raw_public(key):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(409, "existing device identity mismatch or certificate expired") from None
|
||||
return device["cert"]
|
||||
|
||||
if existing:
|
||||
cert = check_existing(existing)
|
||||
else:
|
||||
if not settings.enrollment_signer_url:
|
||||
raise HTTPException(503, "automatic registration is not enabled; update ECS first")
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= settings.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
await rate_limit(redis, "auto-register-total", settings.max_pending, 3600)
|
||||
try:
|
||||
cert = await request_certificate(settings, body)
|
||||
issued = verify_device(cert, settings.ca_cert.read_bytes(), body.host_id)
|
||||
if raw_public(issued) != raw_public(key):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(503, "certificate issuer unavailable or invalid response") from None
|
||||
from .store import INTEGRITY_ERRORS
|
||||
try:
|
||||
store.add_device(body.host_id, cert, fingerprint(cert))
|
||||
except INTEGRITY_ERRORS:
|
||||
# A retry/concurrent request must return the original certificate.
|
||||
cert = check_existing(store.device(body.host_id))
|
||||
store.audit("device", "automatic_registration", body.host_id, "success")
|
||||
await redis.set("hn:device:" + body.host_id, fingerprint(cert))
|
||||
return no_cache(JSONResponse(sign({"status": "registered", "host_id": body.host_id,
|
||||
"cert": cert}, signer), status_code=201 if not existing else 200))
|
||||
|
||||
@router.post("/device/enroll")
|
||||
async def request_enrollment(body: EnrollmentRequest, request: Request):
|
||||
await rate_limit(redis, "enroll-ip:" + peer(request), 10)
|
||||
validate_enrollment(body)
|
||||
await rate_limit(redis, "enroll-host:" + body.host_id, 3, 3600)
|
||||
if store.device(body.host_id):
|
||||
raise HTTPException(409, "device already registered; recover its original certificate")
|
||||
# Global rolling capacity bound; prevents anonymous request-table exhaustion.
|
||||
await rate_limit(redis, "enroll-global", settings.max_pending, 1800)
|
||||
identifier, claim_secret = secrets.token_hex(16), secrets.token_urlsafe(32)
|
||||
record = {"host_id": body.host_id, "public_key": body.public_key,
|
||||
"claim_hash": digest(claim_secret), "created": time.time(), "status": "pending"}
|
||||
await redis.set("hn:enroll:" + identifier, json.dumps(record), ex=1800)
|
||||
return no_cache(JSONResponse(sign({"request_id": identifier, "claim_secret": claim_secret,
|
||||
"host_id": body.host_id, "expires_in": 1800}, signer), status_code=201))
|
||||
|
||||
@router.get("/device/enroll/{identifier}")
|
||||
async def claim(identifier: str, request: Request):
|
||||
await rate_limit(redis, "enroll-poll:" + peer(request), 60)
|
||||
data = await redis.get("hn:enroll:" + identifier)
|
||||
if not data:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(data)
|
||||
import hmac
|
||||
if not hmac.compare_digest(record["claim_hash"], digest(request.headers.get("X-Enrollment-Secret", ""))):
|
||||
raise HTTPException(404, "request unavailable")
|
||||
if record["status"] == "pending":
|
||||
return no_cache(JSONResponse({"status": "pending"}, status_code=202))
|
||||
device = store.device(record["host_id"])
|
||||
if not device or device["revoked"]:
|
||||
raise HTTPException(403, "device unavailable")
|
||||
# Recoverable for its original claimant for the request TTL; public certificate only.
|
||||
return no_cache(JSONResponse(sign({"status": "approved", "host_id": record["host_id"],
|
||||
"request_id": identifier, "cert": device["cert"]}, signer)))
|
||||
|
||||
@router.get("/admin/enrollments/{identifier}")
|
||||
async def inspect(identifier: str, request: Request):
|
||||
admin(request)
|
||||
encoded = await redis.get("hn:enroll:" + identifier)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(encoded)
|
||||
return {k: v for k, v in record.items() if k != "claim_hash"}
|
||||
|
||||
@router.post("/admin/enrollments/{identifier}/approve")
|
||||
async def approve(identifier: str, body: EnrollmentApproval, request: Request):
|
||||
admin(request)
|
||||
encoded = await redis.get("hn:enroll:" + identifier)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(encoded)
|
||||
try:
|
||||
public = verify_device(body.cert, settings.ca_cert.read_bytes(), record["host_id"])
|
||||
requested = serialization.load_pem_public_key(record["public_key"].encode())
|
||||
if raw_public(public) != raw_public(requested):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(400, "certificate does not match enrollment") from None
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= settings.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
fp = fingerprint(body.cert)
|
||||
existing = store.device(record["host_id"])
|
||||
if existing and (existing["revoked"] or existing["fingerprint"] != fp):
|
||||
raise HTTPException(409, "device conflict")
|
||||
if not existing:
|
||||
from .store import INTEGRITY_ERRORS
|
||||
try:
|
||||
store.add_device(record["host_id"], body.cert, fp)
|
||||
except INTEGRITY_ERRORS:
|
||||
raise HTTPException(409, "concurrent device registration") from None
|
||||
await redis.set("hn:device:" + record["host_id"], fp)
|
||||
record["status"] = "approved"
|
||||
remaining = await redis.ttl("hn:enroll:" + identifier)
|
||||
if remaining < 1:
|
||||
raise HTTPException(409, "request expired during approval")
|
||||
await redis.set("hn:enroll:" + identifier, json.dumps(record), ex=remaining)
|
||||
store.audit("admin", "enrollment_approved", record["host_id"], "success")
|
||||
return {"status": "approved", "host_id": record["host_id"]}
|
||||
|
||||
return router
|
||||
@@ -0,0 +1,43 @@
|
||||
"""Internal automatic CA issuer. No published host port, no application credentials."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from cryptography import x509
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from fastapi import FastAPI, Request
|
||||
from .common import BodyLimitMiddleware, require_secret
|
||||
from .crypto import load_private, issue_device, raw_public, verify_device
|
||||
from .enrollment import EnrollmentRequest, validate_enrollment
|
||||
|
||||
|
||||
def create_app(*, ca_key_path=None, ca_cert_path=None, secret=None):
|
||||
key = load_private(Path(ca_key_path or os.environ.get("HN_ISSUER_CA_KEY", "/issuer/ca.key")))
|
||||
ca_bytes = Path(ca_cert_path or os.environ.get("HN_ISSUER_CA_CERT", "/trust/ca.pem")).read_bytes()
|
||||
ca = x509.load_pem_x509_certificate(ca_bytes)
|
||||
if raw_public(key.public_key()) != raw_public(ca.public_key()):
|
||||
raise ValueError("issuer CA key mismatch")
|
||||
token = secret or os.environ.get("HN_INTERNAL_SECRET", "")
|
||||
if len(token) < 32:
|
||||
raise ValueError("issuer requires internal credential")
|
||||
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app.add_middleware(BodyLimitMiddleware, max_body=16384)
|
||||
|
||||
@app.get("/ready")
|
||||
async def ready():
|
||||
return {"status": "ready"}
|
||||
|
||||
@app.post("/issue")
|
||||
async def issue(body: EnrollmentRequest, request: Request):
|
||||
require_secret(request.headers.get("X-Internal-Secret"), token)
|
||||
public = validate_enrollment(body)
|
||||
cert = issue_device(key, ca, body.host_id, public).public_bytes(serialization.Encoding.PEM).decode()
|
||||
verify_device(cert, ca_bytes, body.host_id)
|
||||
return {"cert": cert}
|
||||
|
||||
return app
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import uvicorn
|
||||
uvicorn.run("relay.enrollment_signer:create_app", factory=True, host="0.0.0.0", port=8000,
|
||||
workers=1, access_log=False, proxy_headers=False, log_level="warning")
|
||||
@@ -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,144 @@
|
||||
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
|
||||
owner: str = ""
|
||||
|
||||
|
||||
class Empty(BaseModel):
|
||||
host_id: str = ""
|
||||
proof: dict = Field(default_factory=dict)
|
||||
|
||||
|
||||
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)
|
||||
owner = ""
|
||||
if body.host_id:
|
||||
from .work_api import device_owner
|
||||
owner = await device_owner(self.settings, self.redis, self.store, body.host_id,
|
||||
body.proof, "work-oauth-v1", {})
|
||||
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, owner=owner)
|
||||
redirect = self.settings.public_url.rstrip("/") + "/oauth/cb"
|
||||
parameters = {"app_id": self.settings.feishu_app_id, "redirect_uri": redirect, "state": state}
|
||||
if self.settings.feishu_oauth_scopes:
|
||||
parameters["scope"] = self.settings.feishu_oauth_scopes
|
||||
url = self.settings.feishu_authorize_url + "?" + urlencode(parameters)
|
||||
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 = "", error: str = ""):
|
||||
await rate_limit(self.redis, "oauth:cb:" + peer(request))
|
||||
async with self.lock:
|
||||
self.prune()
|
||||
item = self.pending.get(state)
|
||||
if error and item and item.status == "waiting":
|
||||
item.status = "failed"
|
||||
return no_cache(HTMLResponse("<meta charset='utf-8'><p>授权未完成,请返回客户端重新授权。</p>", status_code=400))
|
||||
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)
|
||||
info = await self.platform.user_info(result["user_access_token"])
|
||||
if not info.get("open_id") or (item.owner and info["open_id"] != item.owner):
|
||||
raise PlatformError("authorization user mismatch")
|
||||
result["open_id"] = info["open_id"]
|
||||
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"
|
||||
item.expires = min(item.expires, time.monotonic() + 60)
|
||||
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,92 @@
|
||||
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, trust_env=False)
|
||||
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})
|
||||
result = self.normalize(data["data"])
|
||||
info = await self.user_info(result["user_access_token"])
|
||||
result["open_id"] = info["open_id"]
|
||||
return result
|
||||
|
||||
@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.get("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,46 @@
|
||||
"""Per-device advisory process lock: same-user GUI and CLI cannot race."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class DeviceAlreadyRunning(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class DeviceProcessLock:
|
||||
def __init__(self, directory):
|
||||
self.path = Path(directory) / "bridge.lock"
|
||||
self.file = None
|
||||
|
||||
def __enter__(self):
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.file = self.path.open("a+b")
|
||||
self.file.seek(0, 2)
|
||||
if self.file.tell() == 0:
|
||||
self.file.write(b"0")
|
||||
self.file.flush()
|
||||
self.file.seek(0)
|
||||
try:
|
||||
if os.name == "nt":
|
||||
import msvcrt
|
||||
msvcrt.locking(self.file.fileno(), msvcrt.LK_NBLCK, 1)
|
||||
else:
|
||||
import fcntl
|
||||
fcntl.flock(self.file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
except OSError:
|
||||
self.file.close()
|
||||
self.file = None
|
||||
raise DeviceAlreadyRunning("该设备已有桥接进程运行,请勿重复启动。") from None
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
if self.file:
|
||||
self.file.seek(0)
|
||||
if os.name == "nt":
|
||||
import msvcrt
|
||||
msvcrt.locking(self.file.fileno(), msvcrt.LK_UNLCK, 1)
|
||||
else:
|
||||
import fcntl
|
||||
fcntl.flock(self.file.fileno(), fcntl.LOCK_UN)
|
||||
self.file.close()
|
||||
self.file = None
|
||||
@@ -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,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
|
||||
@@ -0,0 +1,40 @@
|
||||
"""Current-user Windows DPAPI for device keys; never uses machine-wide scope."""
|
||||
import ctypes
|
||||
import os
|
||||
from ctypes import wintypes
|
||||
|
||||
|
||||
class Blob(ctypes.Structure):
|
||||
_fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_ubyte))]
|
||||
|
||||
|
||||
def transform(data, decrypt=False):
|
||||
if os.name != "nt":
|
||||
raise RuntimeError("DPAPI is supported only on Windows")
|
||||
buffer = (ctypes.c_ubyte * len(data)).from_buffer_copy(data)
|
||||
source = Blob(len(data), buffer)
|
||||
target = Blob()
|
||||
crypt = ctypes.WinDLL("crypt32", use_last_error=True)
|
||||
kernel = ctypes.WinDLL("kernel32", use_last_error=True)
|
||||
if decrypt:
|
||||
fn = crypt.CryptUnprotectData
|
||||
args = [ctypes.byref(source), None, None, None, None, 1, ctypes.byref(target)]
|
||||
else:
|
||||
fn = crypt.CryptProtectData
|
||||
args = [ctypes.byref(source), "Hainuo device identity", None, None, None, 1, ctypes.byref(target)]
|
||||
fn.restype = wintypes.BOOL
|
||||
if not fn(*args):
|
||||
raise ctypes.WinError(ctypes.get_last_error())
|
||||
try:
|
||||
return ctypes.string_at(target.pbData, target.cbData)
|
||||
finally:
|
||||
kernel.LocalFree.argtypes = [ctypes.c_void_p]
|
||||
kernel.LocalFree(target.pbData)
|
||||
|
||||
|
||||
def protect(data):
|
||||
return transform(data)
|
||||
|
||||
|
||||
def unprotect(data):
|
||||
return transform(data, decrypt=True)
|
||||
@@ -0,0 +1,142 @@
|
||||
"""Device-authenticated USER-token business gateway; no tenant-token fallback."""
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import time
|
||||
from urllib.parse import unquote
|
||||
|
||||
import httpx
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from pydantic import BaseModel, Field
|
||||
from .common import no_cache, rate_limit
|
||||
from .crypto import canonical, verified, verify_device
|
||||
from .store import INTEGRITY_ERRORS
|
||||
|
||||
|
||||
class DeviceProof(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
proof: dict
|
||||
|
||||
|
||||
class BusinessCall(DeviceProof):
|
||||
method: str = Field(pattern=r"^(GET|POST|PATCH|DELETE)$")
|
||||
path: str = Field(max_length=1500)
|
||||
params: dict = Field(default_factory=dict)
|
||||
body: dict = Field(default_factory=dict)
|
||||
operation_id: str = Field(default="", max_length=100)
|
||||
|
||||
|
||||
def business_allowed(method, path):
|
||||
if any(x in unquote(path) for x in ("..", "\\", "%", "?", "#", "\r", "\n")):
|
||||
return False
|
||||
seg = r"[A-Za-z0-9_.@-]+"
|
||||
cal = r"/open-apis/calendar/v4/calendars"
|
||||
rules = {
|
||||
"GET": [cal, cal + "/" + seg, cal + "/" + seg + "/events(?:/" + seg + ")?(?:/attendees)?",
|
||||
r"/open-apis/contact/v3/users/" + seg, r"/open-apis/search/v1/user",
|
||||
r"/open-apis/(?:drive/v1/files|docx/v1/documents|wiki/v2/spaces|bitable/v1/apps)(?:/" + seg + ")*"],
|
||||
"POST": [cal + "/primary", cal + "/" + seg + "/events(?:/" + seg + "/attendees)?"],
|
||||
"PATCH": [cal + "/" + seg + "/events/" + seg],
|
||||
"DELETE": [cal + "/" + seg + "/events/" + seg, cal + "/" + seg + "/events/" + seg + "/attendees/" + seg],
|
||||
}
|
||||
return any(re.fullmatch(p, path) for p in rules.get(method, []))
|
||||
|
||||
|
||||
async def device_owner(settings, redis, store, host, proof, purpose, payload):
|
||||
device = store.device(host)
|
||||
if not device or device["revoked"] or not device["owner"]:
|
||||
raise HTTPException(403, "active bound device required")
|
||||
try:
|
||||
key = verify_device(device["cert"], settings.ca_cert.read_bytes(), host)
|
||||
data = verified(proof, key)
|
||||
if (data["host_id"] != host or data["purpose"] != purpose or abs(time.time() - data["ts"]) > 90
|
||||
or not re.fullmatch(r"[a-f0-9]{32}", data["nonce"])
|
||||
or data["payload_hash"] != hashlib.sha256(canonical(payload)).hexdigest()):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid device request proof") from None
|
||||
if not await redis.set("hn:work-proof:" + host + ":" + data["nonce"], "1", nx=True, ex=180):
|
||||
raise HTTPException(409, "device request replayed")
|
||||
return device["owner"]
|
||||
|
||||
|
||||
def router(settings, redis, store, platform):
|
||||
routes = APIRouter()
|
||||
store.db.execute("""CREATE TABLE IF NOT EXISTS business_operations(
|
||||
owner TEXT NOT NULL, operation_id TEXT NOT NULL, request_hash TEXT NOT NULL,
|
||||
status TEXT NOT NULL, result_meta TEXT NOT NULL, created DOUBLE PRECISION NOT NULL,
|
||||
PRIMARY KEY(owner,operation_id))""")
|
||||
if not settings.database_url:
|
||||
store.db.commit()
|
||||
|
||||
@routes.post("/work/api")
|
||||
async def call(body: BusinessCall, request: Request):
|
||||
if not settings.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
auth = request.headers.get("Authorization", "")
|
||||
if not auth.startswith("Bearer ") or not 10 < len(auth) <= 8192:
|
||||
raise HTTPException(401, "user access token required")
|
||||
if not business_allowed(body.method, body.path):
|
||||
raise HTTPException(403, "business method/path not supported")
|
||||
payload = {"method": body.method, "path": body.path, "params": body.params, "body": body.body,
|
||||
"operation_id": body.operation_id, "token_hash": hashlib.sha256(auth[7:].encode()).hexdigest()}
|
||||
owner = await device_owner(settings, redis, store, body.host_id, body.proof, "work-api-v1", payload)
|
||||
await rate_limit(redis, "work-api:" + owner, 60)
|
||||
try:
|
||||
info = await platform.user_info(auth[7:])
|
||||
except Exception:
|
||||
raise HTTPException(401, "user token expired or invalid; refresh or authorize") from None
|
||||
if info.get("open_id") != owner:
|
||||
raise HTTPException(403, "token user does not match bound device owner")
|
||||
write = body.method != "GET" and not body.path.endswith(("/primary", "/batch_get_id"))
|
||||
digest = hashlib.sha256(canonical({k: v for k, v in payload.items() if k != "token_hash"})).hexdigest()
|
||||
if write:
|
||||
if not re.fullmatch(r"[A-Za-z0-9_-]{8,100}", body.operation_id):
|
||||
raise HTTPException(422, "write requires stable operation_id")
|
||||
try:
|
||||
with store.db:
|
||||
store.db.execute("INSERT INTO business_operations VALUES(?,?,?,?,?,?)",
|
||||
(owner, body.operation_id, digest, "inflight", "{}", time.time()))
|
||||
except INTEGRITY_ERRORS:
|
||||
row = dict(store.db.execute("SELECT * FROM business_operations WHERE owner=? AND operation_id=?",
|
||||
(owner, body.operation_id)).fetchone())
|
||||
if row["request_hash"] != digest:
|
||||
raise HTTPException(409, "operation_id reused with different request")
|
||||
return no_cache(JSONResponse({"status": "duplicate", "operation_id": body.operation_id,
|
||||
"previous_status": row["status"], **json.loads(row["result_meta"])}))
|
||||
params = dict(body.params)
|
||||
if write and body.method == "POST" and body.path.endswith("/events"):
|
||||
params["idempotency_key"] = hashlib.sha256((owner + body.operation_id).encode()).hexdigest()
|
||||
try:
|
||||
async with platform.http.stream(body.method, body.path, params=params,
|
||||
json=body.body if body.method != "GET" else None,
|
||||
headers={"Authorization": auth}) as upstream:
|
||||
raw = bytearray()
|
||||
async for chunk in upstream.aiter_bytes():
|
||||
raw.extend(chunk)
|
||||
if len(raw) > 2 * 1024 * 1024:
|
||||
raise ValueError()
|
||||
data = json.loads(raw)
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError()
|
||||
code = data.get("code", 0)
|
||||
if upstream.status_code != 200 or code != 0:
|
||||
status = "platform_rejected"
|
||||
result = {"status": status, "http_status": upstream.status_code, "platform_code": code,
|
||||
"message": "平台拒绝:请核对用户授权、应用scope、资源权限或接口版本。"}
|
||||
else:
|
||||
status, result = "completed", {"status": "completed", "data": data.get("data", {})}
|
||||
except (httpx.HTTPError, ValueError):
|
||||
status = "unknown" if write else "failed"
|
||||
result = {"status": status, "message": "平台请求未取得明确结果;写操作不要换新ID重试,请先核对日历。"}
|
||||
if write:
|
||||
event = result.get("data", {}).get("event", {})
|
||||
meta = {k: event[k] for k in ("event_id", "app_link") if k in event}
|
||||
with store.db:
|
||||
store.db.execute("UPDATE business_operations SET status=?,result_meta=? WHERE owner=? AND operation_id=?",
|
||||
(status, json.dumps(meta), owner, body.operation_id))
|
||||
store.audit(owner, "work_api_" + body.method.lower(), body.path, status)
|
||||
return no_cache(JSONResponse(result))
|
||||
|
||||
return routes
|
||||
@@ -0,0 +1,190 @@
|
||||
"""PC-side user OAuth and calendar operations. Tokens are DPAPI-protected only here."""
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
import ssl
|
||||
import time
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote, urlsplit
|
||||
|
||||
import httpx
|
||||
from .crypto import canonical, load_private, sign
|
||||
from .windows_keys import protect, unprotect
|
||||
from .process_lock import DeviceProcessLock
|
||||
|
||||
|
||||
class WorkError(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class AuthorizationRequired(WorkError):
|
||||
def __init__(self, url):
|
||||
self.url = url
|
||||
super().__init__("需要本人Work授权,请打开授权链接,完成后重新发起原任务;尚未执行平台写操作。")
|
||||
|
||||
|
||||
def atomic_secret(path, data):
|
||||
temp = path.with_suffix(".tmp")
|
||||
temp.write_bytes(protect(json.dumps(data, ensure_ascii=False).encode()))
|
||||
temp.replace(path)
|
||||
|
||||
|
||||
class WorkClient:
|
||||
def __init__(self, directory, url="https://10.77.76.13", *, transport=None):
|
||||
self.directory = Path(directory)
|
||||
self.config = json.loads((self.directory / "device.json").read_text(encoding="utf-8-sig"))
|
||||
if not self.config.get("owner"):
|
||||
raise WorkError("请先绑定本人Work身份。")
|
||||
context = ssl.create_default_context(cafile=str(self.directory / "server.pem"))
|
||||
self.http = httpx.Client(base_url=url.rstrip("/"), verify=context, trust_env=False,
|
||||
timeout=25, follow_redirects=False, transport=transport)
|
||||
self.owner = self.config["owner"]
|
||||
self.path = self.directory / "work-user-tokens.dpapi"
|
||||
self.pending = self.directory / "work-oauth-pending.dpapi"
|
||||
|
||||
def close(self):
|
||||
self.http.close()
|
||||
|
||||
def read(self, path):
|
||||
return json.loads(unprotect(path.read_bytes()))
|
||||
|
||||
def proof(self, purpose, payload):
|
||||
return sign({"host_id": self.config["host_id"], "purpose": purpose, "ts": int(time.time()),
|
||||
"nonce": secrets.token_hex(16), "payload_hash": hashlib.sha256(canonical(payload)).hexdigest()},
|
||||
load_private(self.directory / "device.key"))
|
||||
|
||||
def authorize(self):
|
||||
if self.pending.exists():
|
||||
data = self.read(self.pending)
|
||||
if data.get("owner") == self.owner and data["deadline"] > time.time():
|
||||
return data["authorization_url"]
|
||||
response = self.http.post("/oauth/start", json={"host_id": self.config["host_id"],
|
||||
"proof": self.proof("work-oauth-v1", {})})
|
||||
if response.status_code != 201:
|
||||
raise WorkError("授权事务创建失败(HTTP " + str(response.status_code) + "),请检查ECS平台配置。")
|
||||
data = response.json()
|
||||
if urlsplit(data["authorization_url"]).scheme != "https":
|
||||
raise WorkError("授权地址必须使用HTTPS。")
|
||||
data.update(owner=self.owner, deadline=time.time() + data["expires_in"])
|
||||
atomic_secret(self.pending, data)
|
||||
return data["authorization_url"]
|
||||
|
||||
def save_tokens(self, data):
|
||||
if data.get("open_id") != self.owner or not data.get("user_access_token"):
|
||||
raise WorkError("授权账号与本机Work绑定账号不一致,请使用本人账号重新授权。")
|
||||
now = time.time()
|
||||
data = {**data, "expires_at": now + int(data["expires_in"]),
|
||||
"refresh_expires_at": now + int(data.get("refresh_expires_in", 0)), "needs_authorization": False}
|
||||
atomic_secret(self.path, data)
|
||||
return data
|
||||
|
||||
def access_token(self):
|
||||
# Shared across GUI and Agent calls; never rotate the same token concurrently.
|
||||
with DeviceProcessLock(self.directory / "work-token-lock"):
|
||||
if self.path.exists():
|
||||
data = self.read(self.path)
|
||||
if data.get("open_id") == self.owner and not data.get("needs_authorization"):
|
||||
if data["expires_at"] > time.time() + 120:
|
||||
return data["user_access_token"]
|
||||
if data.get("refresh_token") and data.get("refresh_expires_at", 0) > time.time():
|
||||
# Mark before network; ambiguous failure must not reuse a rotating refresh token.
|
||||
atomic_secret(self.path, {**data, "needs_authorization": True})
|
||||
try:
|
||||
response = self.http.post("/oauth/refresh", json={"refresh_token": data["refresh_token"]})
|
||||
if response.status_code != 200:
|
||||
raise WorkError("刷新失败")
|
||||
data = self.save_tokens(response.json())
|
||||
return data["user_access_token"]
|
||||
except (httpx.HTTPError, ValueError, WorkError):
|
||||
raise AuthorizationRequired(self.authorize()) from None
|
||||
if self.pending.exists():
|
||||
pending = self.read(self.pending)
|
||||
if pending.get("owner") == self.owner and pending["deadline"] > time.time():
|
||||
response = self.http.get("/oauth/claim", params={"state": pending["state"]},
|
||||
headers={"X-OAuth-Claim-Secret": pending["claim_secret"]})
|
||||
if response.status_code == 200:
|
||||
data = self.save_tokens(response.json())
|
||||
self.pending.unlink(missing_ok=True)
|
||||
return data["user_access_token"]
|
||||
if response.status_code not in {202}:
|
||||
self.pending.unlink(missing_ok=True)
|
||||
raise AuthorizationRequired(self.authorize())
|
||||
|
||||
def status(self):
|
||||
try:
|
||||
token = self.access_token()
|
||||
return {"authorized": True, "owner": self.owner, "message": "本人用户授权可用;令牌未输出。",
|
||||
"local_time": datetime.now().astimezone().isoformat()}
|
||||
except AuthorizationRequired as error:
|
||||
return {"authorized": False, "authorization_url": error.url, "message": str(error)}
|
||||
|
||||
def api(self, method, path, params=None, body=None, operation_id=""):
|
||||
token = self.access_token()
|
||||
payload = {"method": method, "path": path, "params": params or {}, "body": body or {},
|
||||
"operation_id": operation_id, "token_hash": hashlib.sha256(token.encode()).hexdigest()}
|
||||
proof = self.proof("work-api-v1", payload)
|
||||
wire = {k: v for k, v in payload.items() if k != "token_hash"}
|
||||
response = self.http.post("/work/api", headers={"Authorization": "Bearer " + token},
|
||||
json={**wire, "host_id": self.config["host_id"], "proof": proof})
|
||||
if response.status_code == 401:
|
||||
# Do not repeat a business write automatically, even when auth fails.
|
||||
if self.path.exists():
|
||||
data = self.read(self.path)
|
||||
data["expires_at"] = 0
|
||||
atomic_secret(self.path, data)
|
||||
raise WorkError("用户令牌已失效。本次未重试,请检查授权后再核对操作状态。")
|
||||
if response.status_code != 200:
|
||||
raise WorkError("平台代理失败(HTTP " + str(response.status_code) + ");未重试。")
|
||||
return response.json()
|
||||
|
||||
def primary_calendar(self):
|
||||
result = self.api("POST", "/open-apis/calendar/v4/calendars/primary", {"user_id_type": "open_id"})
|
||||
if result.get("status") != "completed":
|
||||
return result
|
||||
calendars = result.get("data", {}).get("calendars", [])
|
||||
own = [c["calendar"] for c in calendars if c.get("user_id") == self.owner and c.get("calendar")]
|
||||
if not own and len(calendars) == 1 and not calendars[0].get("user_id") and calendars[0].get("calendar"):
|
||||
own = [calendars[0]["calendar"]]
|
||||
if len(own) != 1:
|
||||
raise WorkError("没有唯一确定的本人主日历,请先查询日历列表并明确选择。")
|
||||
return {"status": "completed", "calendar": own[0]}
|
||||
|
||||
def create_event(self, summary, start_iso, end_iso, attendee_open_ids, operation_id, description="", calendar_id=""):
|
||||
import re
|
||||
if not re.fullmatch(r"[A-Za-z0-9_-]{8,80}", operation_id):
|
||||
raise WorkError("创建日程需8到80位稳定operation_id,重试不得换ID。")
|
||||
if not summary.strip() or len(summary) > 1000:
|
||||
raise WorkError("日程主题不能为空或超过1000字符。")
|
||||
start, end = datetime.fromisoformat(start_iso), datetime.fromisoformat(end_iso)
|
||||
if start.tzinfo is None or end.tzinfo is None or end <= start:
|
||||
raise WorkError("起止时间必须包含时区且结束晚于开始;不要猜测时区或时长。")
|
||||
if any(not isinstance(x, str) or not x.startswith("ou_") for x in attendee_open_ids):
|
||||
raise WorkError("参会人必须为当前应用身份域的open_id,请先搜索并确认,不能把姓名/工号直接当ID。")
|
||||
if not calendar_id:
|
||||
primary = self.primary_calendar()
|
||||
if primary.get("status") != "completed":
|
||||
return primary
|
||||
calendar_id = primary["calendar"]["calendar_id"]
|
||||
path = "/open-apis/calendar/v4/calendars/" + quote(calendar_id, safe="") + "/events"
|
||||
body = {"summary": summary, "description": description, "need_notification": True,
|
||||
"start_time": {"timestamp": str(int(start.timestamp())), "timezone": "Asia/Shanghai"},
|
||||
"end_time": {"timestamp": str(int(end.timestamp())), "timezone": "Asia/Shanghai"}}
|
||||
result = self.api("POST", path, {"user_id_type": "open_id"}, body, operation_id)
|
||||
event = result.get("data", {}).get("event", {})
|
||||
if result.get("status") == "duplicate" and result.get("previous_status") == "completed":
|
||||
event = {"event_id": result.get("event_id"), "app_link": result.get("app_link")}
|
||||
elif result.get("status") != "completed":
|
||||
return result
|
||||
if not event.get("event_id"):
|
||||
raise WorkError("平台未返回event_id,不能认定创建成功或继续邀请。")
|
||||
ids = sorted(set([self.owner] + list(attendee_open_ids)))
|
||||
invite = self.api("POST", path + "/" + quote(event["event_id"], safe="") + "/attendees",
|
||||
{"user_id_type": "open_id"},
|
||||
{"attendees": [{"type": "user", "user_id": x} for x in ids], "need_notification": True},
|
||||
operation_id + "_attendees")
|
||||
invited = invite.get("status") == "completed" or (invite.get("status") == "duplicate" and invite.get("previous_status") == "completed")
|
||||
return {"status": "completed" if invited else "partial", "event_created": True,
|
||||
"calendar_id": calendar_id, "event_id": event["event_id"], "app_link": event.get("app_link"),
|
||||
"attendees_invited": invited, "invite_result": invite,
|
||||
"message": "日程已创建并提交参会人邀请;不代表对方已接受。" if invited else "日程已创建,但邀请未完成;保留原操作ID和event_id处理,勿重新创建日程。"}
|
||||
@@ -0,0 +1,145 @@
|
||||
"""Hermes native tools backed by the authenticated user-token relay."""
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
from pathlib import Path
|
||||
import httpx
|
||||
from .work_client import WorkClient, WorkError, AuthorizationRequired
|
||||
|
||||
INSTRUCTIONS = """海能Work平台能力已接入本机专用工具:work_authorization、work_calendar、work_contacts、work_api_request。
|
||||
涉及飞书/海能Work日历或文档时优先调用这些工具,勿使用manage_connections寻找公有云连接器,勿索要或搜索App Secret。
|
||||
用户token仅由本机安全存储和ECS换取,第一次需要本人打开授权链接。工具返回authorization_required时将链接完整提供给本人,不能声称已经创建。
|
||||
当前日期以work_authorization返回的local_time为准。创建日程必须确定带时区的起止时间和真实参会人open_id。
|
||||
姓名/工号须用work_contacts搜索核实,多个候选必须澄清,不能猜open_id。平台返回partial表示已创建但邀请未完成,勿再次创建。
|
||||
同一写操作的operation_id必须保持不变,网络异常不得换ID重试。日程创建成功、邀请提交成功、对方接受是不同状态。
|
||||
"""
|
||||
|
||||
_watching = set()
|
||||
_watch_lock = threading.Lock()
|
||||
|
||||
|
||||
def watch_authorization(directory):
|
||||
"""Claim within the server's 60-second result TTL, without keeping tokens in ECS."""
|
||||
name = str(directory)
|
||||
with _watch_lock:
|
||||
if name in _watching:
|
||||
return
|
||||
_watching.add(name)
|
||||
def poll():
|
||||
client = None
|
||||
try:
|
||||
client = WorkClient(directory, os.environ.get("HN_WORK_RELAY_URL", "https://10.77.76.13"))
|
||||
for _ in range(295):
|
||||
time.sleep(2)
|
||||
try:
|
||||
if client.pending.exists() and client.read(client.pending).get("deadline", 0) <= time.time():
|
||||
return
|
||||
if client.status().get("authorized"):
|
||||
return
|
||||
except Exception:
|
||||
# Another local consumer may hold the short token lock.
|
||||
continue
|
||||
except Exception:
|
||||
pass
|
||||
finally:
|
||||
if client:
|
||||
client.close()
|
||||
with _watch_lock:
|
||||
_watching.discard(name)
|
||||
threading.Thread(target=poll, daemon=True, name="work-user-auth-claim").start()
|
||||
|
||||
|
||||
def register(directory):
|
||||
from tools.registry import registry
|
||||
import toolsets
|
||||
definitions = [
|
||||
("work_authorization", "查询或发起本人海能Work用户授权,返回可点击链接和本机时间;不返回token。", {
|
||||
"type": "object", "properties": {}, "additionalProperties": False}),
|
||||
("work_calendar", "本人用户身份的日历:list/primary/list_events/get_event/create_event/invite。写操作operation_id需稳定,起止时间均带时区。", {
|
||||
"type": "object", "properties": {
|
||||
"action": {"type": "string", "enum": ["list", "primary", "list_events", "get_event", "create_event", "invite"]},
|
||||
"calendar_id": {"type": "string"}, "event_id": {"type": "string"},
|
||||
"summary": {"type": "string"}, "description": {"type": "string"},
|
||||
"start_iso": {"type": "string", "description": "ISO8601,例如2026-10-27T09:00:00+08:00"},
|
||||
"end_iso": {"type": "string"}, "attendee_open_ids": {"type": "array", "items": {"type": "string"}},
|
||||
"operation_id": {"type": "string", "description": "8-80位稳定操作ID,同一意图重试不能更换"},
|
||||
"params": {"type": "object"}}, "required": ["action"]}),
|
||||
("work_contacts", "使用本人user token搜索参会人;query可为姓名或工号,返回候选,不能未经核实猜ID。open_id可读取具体用户信息。", {
|
||||
"type": "object", "properties": {"query": {"type": "string"}, "open_id": {"type": "string"}}}),
|
||||
("work_api_request", "携本人user token代理受支持业务API(日历CRUD/邀请、通讯录查询、文档云盘知识库读取)。禁止认证接口,不支持的路径返回403。写操作必须operation_id。", {
|
||||
"type": "object", "properties": {"method": {"type": "string", "enum": ["GET", "POST", "PATCH", "DELETE"]},
|
||||
"path": {"type": "string"}, "params": {"type": "object"}, "body": {"type": "object"},
|
||||
"operation_id": {"type": "string"}}, "required": ["method", "path"]}),
|
||||
]
|
||||
|
||||
def handler_for(name):
|
||||
def handle(args, **kwargs):
|
||||
client = None
|
||||
try:
|
||||
client = WorkClient(directory, os.environ.get("HN_WORK_RELAY_URL", "https://10.77.76.13"))
|
||||
if name == "work_authorization":
|
||||
result = client.status()
|
||||
if not result.get("authorized"):
|
||||
watch_authorization(directory)
|
||||
elif name == "work_api_request":
|
||||
result = client.api(**args)
|
||||
elif name == "work_contacts":
|
||||
from urllib.parse import quote
|
||||
result = client.api("GET", "/open-apis/contact/v3/users/" + quote(args["open_id"], safe=""),
|
||||
{"user_id_type": "open_id"}) if args.get("open_id") else client.api(
|
||||
"GET", "/open-apis/search/v1/user", {"query": args.get("query", ""), "page_size": 20})
|
||||
else:
|
||||
result = calendar(client, args)
|
||||
return json.dumps(result, ensure_ascii=False)
|
||||
except AuthorizationRequired as error:
|
||||
watch_authorization(directory)
|
||||
return json.dumps({"status": "authorization_required", "authorization_url": error.url, "message": str(error)}, ensure_ascii=False)
|
||||
except (WorkError, ValueError, KeyError) as error:
|
||||
return json.dumps({"error": str(error)[:500], "status": "failed"}, ensure_ascii=False)
|
||||
except Exception as error:
|
||||
return json.dumps({"error": type(error).__name__ + ";操作状态未确认,未自动重试。"}, ensure_ascii=False)
|
||||
finally:
|
||||
if client:
|
||||
client.close()
|
||||
return handle
|
||||
|
||||
for name, description, parameters in definitions:
|
||||
registry.register(name=name, toolset="hainuo_work", schema={"name": name, "description": description, "parameters": parameters},
|
||||
handler=handler_for(name), description=description)
|
||||
toolsets.TOOLSETS["hainuo_work"] = {"description": "海能Work本人用户授权及日历业务", "tools": [x[0] for x in definitions], "includes": []}
|
||||
# Present these four small schemas directly; otherwise Hermes defers custom
|
||||
# toolsets behind tool_search and can wrongly search a public-cloud connector.
|
||||
for name, _, _ in definitions:
|
||||
if name not in toolsets._HERMES_CORE_TOOLS:
|
||||
toolsets._HERMES_CORE_TOOLS.append(name)
|
||||
|
||||
|
||||
def calendar(client, args):
|
||||
from urllib.parse import quote
|
||||
action = args["action"]
|
||||
if action == "primary":
|
||||
return client.primary_calendar()
|
||||
if action == "list":
|
||||
return client.api("GET", "/open-apis/calendar/v4/calendars", args.get("params", {}))
|
||||
if action == "create_event":
|
||||
return client.create_event(**{k: v for k, v in args.items() if k != "action" and k != "params"})
|
||||
calendar_id = args.get("calendar_id")
|
||||
if not calendar_id:
|
||||
primary = client.primary_calendar()
|
||||
if primary.get("status") != "completed":
|
||||
return primary
|
||||
calendar_id = primary["calendar"]["calendar_id"]
|
||||
base = "/open-apis/calendar/v4/calendars/" + quote(calendar_id, safe="") + "/events"
|
||||
if action == "list_events":
|
||||
return client.api("GET", base, args.get("params", {}))
|
||||
base += "/" + quote(args["event_id"], safe="")
|
||||
if action == "get_event":
|
||||
return client.api("GET", base, {"user_id_type": "open_id"})
|
||||
if action == "invite":
|
||||
ids = args.get("attendee_open_ids", [])
|
||||
if not ids or any(not x.startswith("ou_") for x in ids):
|
||||
raise WorkError("需要已确认的参会人open_id。")
|
||||
return client.api("POST", base + "/attendees", {"user_id_type": "open_id"},
|
||||
{"attendees": [{"type": "user", "user_id": x} for x in ids], "need_notification": True}, args["operation_id"])
|
||||
raise WorkError("不支持的日历操作。")
|
||||
@@ -0,0 +1,20 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
root=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
|
||||
cd "$root"
|
||||
stamp=$(date +%Y%m%d-%H%M%S)
|
||||
docker image tag hainuo-relay:0.1.0 "hainuo-relay:before-userapi-$stamp"
|
||||
docker build --network none --pull=false -f Dockerfile.offline -t hainuo-relay:0.1.0 .
|
||||
args=(-f compose.yaml)
|
||||
for override in compose.offline.yaml compose.edge-fix.yaml compose.h5.yaml compose.work.yaml compose.feishu.yaml compose.autoreg.yaml; do
|
||||
if [[ -f "$override" ]]; then args+=(-f "$override"); fi
|
||||
done
|
||||
args+=(-f compose.userapi.yaml)
|
||||
docker compose "${args[@]}" up -d --no-build --pull never --no-deps --force-recreate connector router
|
||||
if [[ -n "$(docker compose -f compose.yaml ps -q longconn)" ]]; then
|
||||
docker compose "${args[@]}" --profile longconn up -d --no-build --pull never --no-deps --force-recreate longconn
|
||||
fi
|
||||
docker compose "${args[@]}" ps
|
||||
echo "Previous image: hainuo-relay:before-userapi-$stamp"
|
||||
echo 'Keep compose.autoreg.yaml and compose.userapi.yaml in future application recreations.'
|
||||
echo 'Configure platform callback/scopes, then each user completes personal authorization.'
|
||||
@@ -0,0 +1,10 @@
|
||||
FROM python:3.12-slim-bookworm
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1
|
||||
WORKDIR /app
|
||||
COPY wheelhouse /wheels
|
||||
COPY requirements.lock pyproject.toml ./
|
||||
COPY relay ./relay
|
||||
RUN pip install --no-index --find-links=/wheels --no-cache-dir -r requirements.lock && rm -rf /wheels
|
||||
RUN chmod -R a+rX /app
|
||||
USER 10001:10001
|
||||
ENTRYPOINT ["python", "-m", "relay.cli"]
|
||||
@@ -0,0 +1,78 @@
|
||||
# H5配对和真实海诺对话 · 2026-10-26增量
|
||||
|
||||
## 已有环境无需重做
|
||||
|
||||
- ECS:10.77.76.13:443,目录 `/home/cnooc/hainuo-offline-arm64/hainuo-relay`。
|
||||
- PC已绑定 `ou_test_tianzeyuan`,证书目录 `D:\HainuoRelayDevice`。
|
||||
- 实际海诺安装位置 `%LOCALAPPDATA%\Hainuo`,不是示例D:\Hainuo1065。
|
||||
- 本机原生API:127.0.0.1:8643,纯文本模式;ECS→桥接端→真实模型已经返回42。
|
||||
|
||||
本次新增:网页配对、Secure/HttpOnly浏览器会话、设备在线状态、纯文本聊天、离线提示、请求去重、退出登录及绑定变更失效。暂不依赖海能Work OAuth配置。
|
||||
|
||||
## 1. 更新ECS
|
||||
|
||||
将 `hainuo-relay-h5-update-20261026.tar.gz`上传到 `/home/cnooc`,执行:
|
||||
|
||||
```bash
|
||||
tar -xzf /home/cnooc/hainuo-relay-h5-update-20261026.tar.gz \
|
||||
-C /home/cnooc/hainuo-offline-arm64
|
||||
cd /home/cnooc/hainuo-offline-arm64/hainuo-relay
|
||||
sudo bash scripts/update-h5.sh
|
||||
```
|
||||
|
||||
增量包只包含源码、网页资源、更新脚本、Dockerfile和说明,不包含.env、runtime、证书、CA或数据库。更新先保留旧镜像标签,使用原wheelhouse离线构建,只重建连接器;其他组件不重装。连接器重启时在途请求可能中断,等当前任务完成后再更新。
|
||||
|
||||
不要运行旧的install.sh重新初始化,不要重新解压整包覆盖更新后的源码。后续recreate使用compose.h5.yaml,以保留180秒模型等待时间。
|
||||
|
||||
## 2. Windows生成网页配对码
|
||||
|
||||
本机项目已更新 `web-pair`命令,原生API与桥接端保持运行。Windows PowerShell执行:
|
||||
|
||||
```powershell
|
||||
cd "C:\Users\huawei\Desktop\海能h5连接海诺客户端\hainuo-relay"
|
||||
& "..\.venv\Scripts\python.exe" -m relay.cli web-pair `
|
||||
--directory D:\HainuoRelayDevice `
|
||||
--url https://10.77.76.13 `
|
||||
--tls-ca D:\HainuoRelayDevice\server.pem
|
||||
```
|
||||
|
||||
输出网页地址和一次性配对码。有效期120秒;不要发到群里、工单或聊天截图。生成失败HTTP404表示ECS仍是旧版,先完成步骤1。
|
||||
|
||||
## 3. 浏览器配对和聊天
|
||||
|
||||
打开 `https://10.77.76.13/h5`,必要时Ctrl+F5刷新。页面应出现“输入电脑上的配对码”和“连接我的电脑”,不再只有原OAuth按钮。
|
||||
|
||||
粘贴配对码后点击连接。网页显示“你的电脑已在线”后,发送:
|
||||
|
||||
```text
|
||||
请计算17加25,只回复计算结果。
|
||||
```
|
||||
|
||||
预期回复42。普通文本自动加 `/助手`转给本机真实海诺API;`/主机名`和`/回显 内容`保留用于核对目标设备。
|
||||
|
||||
每个消息有独立请求ID;同一ID不会重复执行。网络失败不自动重发;出现状态未知时先核查,不要重复提交有副作用的任务。当前所有原生模型调用禁止工具,不能执行删除等指令。
|
||||
|
||||
## 会话和安全边界
|
||||
|
||||
- 网页登录依靠本机设备私钥签名申请的高熵一次性码,不接受网页自报owner/host作为身份。
|
||||
- 配对码120秒一次消费、会话30分钟固定过期。服务端只保存配对/会话凭据的SHA256索引;浏览器凭据只放Secure、HttpOnly、SameSite=Strict Cookie,不放URL或localStorage。
|
||||
- 网页POST必须Origin与HN_PUBLIC_URL一致;ECS当前应为 `https://10.77.76.13`。不开放任意Origin,不用管理员密钥给网页登录。
|
||||
- 请求主体由浏览器会话确定;切换用户、解绑、吊销或绑定代次变化会失效。另一用户不能通过提交open_id调用你的电脑。
|
||||
- 这是**试点中继网页模式**:浏览器HTTPS在入口终止,B1在内存中处理网页正文,再应用层加密发到PC;B2只见密文。中继不保存聊天正文,网页关闭或退出后当前页面历史不保留。
|
||||
- 这与领导原方案“浏览器TLS直接终止在PC、中心看不到网页正文”不同。不能将本模式称作浏览器到PC端到端加密或正式生产安全验收通过。
|
||||
- 海能Work授权入口仍保留;只有配置真实平台OAuth后才能使用。后续可独立切换平台身份来源。
|
||||
- 本地原生API+桥接端目前是后台进程,电脑重启后需要按原生接入手册恢复启动;尚未实现Windows服务自启动。
|
||||
|
||||
## 验收
|
||||
|
||||
1. 未配对网页不可派发任务,直接访问/web/chat应401。
|
||||
2. 配对后收到42,/主机名与Windows hostname一致。
|
||||
3. 同一配对码第二个浏览器使用失败。
|
||||
4. 退出网页登录后,原Cookie立即无效。
|
||||
5. PC停止桥接端时网页显示离线,新问题返回离线提示;重连后恢复。
|
||||
6. 两个设备不同账号分别配对,消息不串机。
|
||||
7. 跨站Origin不能兑换配对码或派发任务。
|
||||
|
||||
本地自动化用真实HTTP/WebSocket与模拟平台/模型检验链路;真实ECS H5页面更新后的配对与对话,仍需按上述步骤执行验收。
|
||||
|
||||
本轮回归结果:48项通过、1项真实PostgreSQL用例因本地环境缺失跳过。新增9项包含H5会话与原生HTTP组合链路,覆盖一次配对码、并发消费、跨站拒绝、两账号隔离、去重、退出与过期、绑定变更失效。
|
||||
@@ -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", "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 == "revoke":
|
||||
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 == "revoke":
|
||||
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}/revoke"
|
||||
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,60 @@
|
||||
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
|
||||
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_enabled and not all((self.feishu_app_id, self.feishu_app_secret,
|
||||
self.feishu_encrypt_key,
|
||||
self.feishu_verification_token)):
|
||||
raise ValueError("complete platform credentials are required")
|
||||
return self
|
||||
@@ -0,0 +1,478 @@
|
||||
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)}
|
||||
|
||||
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 = "已解绑;重新绑定后请更新本机绑定信息。"
|
||||
else:
|
||||
result = (await broker.dispatch(owner, text, "msg_" + hashlib.sha256(message_id.encode()).hexdigest()))["result"]
|
||||
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")
|
||||
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,105 @@
|
||||
"""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") != "text-only":
|
||||
raise ValueError("only verified text-only mode is supported")
|
||||
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.
|
||||
if policy != {"mode": "text-only", "tools": "disabled", "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": "text-only", "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,59 @@
|
||||
"""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:
|
||||
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")
|
||||
|
||||
handler = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(received).build()
|
||||
try:
|
||||
# domain is an actual supported SDK argument; no public-cloud-domain monkey patch.
|
||||
lark.ws.Client(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__":
|
||||
main()
|
||||
@@ -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:
|
||||
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
|
||||
@@ -0,0 +1,132 @@
|
||||
"""Run the actual 1.065 API adapter, isolated from bot/scheduler startup.
|
||||
|
||||
Run with the installed Hermes Python, not the relay Python. No installer code
|
||||
or existing profiles are edited. Only a separate loopback listener is started.
|
||||
"""
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import secrets
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def prepare_environment(install_root, profile, port, config_path):
|
||||
if not profile or any(c not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-" for c in profile):
|
||||
raise ValueError("invalid profile")
|
||||
source = install_root / "hermes-agent"
|
||||
home = install_root if profile == "default" else install_root / "profiles" / profile
|
||||
if not (source / "gateway/platforms/api_server.py").is_file() or not (home / "config.yaml").is_file():
|
||||
raise RuntimeError("installation/profile does not match installer 1.065 layout")
|
||||
# Environment must be selected before importing any Hermes module (global caches).
|
||||
os.environ["HERMES_HOME"] = str(home.resolve())
|
||||
os.environ["API_SERVER_HOST"] = "127.0.0.1"
|
||||
os.environ["API_SERVER_PORT"] = str(port)
|
||||
os.environ["API_SERVER_CORS_ORIGINS"] = ""
|
||||
os.environ["HERMES_SKIP_CWD_MIGRATION"] = "1"
|
||||
sys.path.insert(0, str(source.resolve()))
|
||||
# Use the package's own dotenv support to reuse the real profile model credentials.
|
||||
from dotenv import load_dotenv
|
||||
load_dotenv(install_root / ".env", override=False)
|
||||
if home != install_root:
|
||||
load_dotenv(home / ".env", override=True)
|
||||
if config_path.exists():
|
||||
data = json.loads(config_path.read_text(encoding="utf-8-sig"))
|
||||
if data.get("url") != f"http://127.0.0.1:{port}" or data.get("mode") != "text-only" or len(data.get("api_key", "")) < 32:
|
||||
raise ValueError("existing local adapter config does not match listener")
|
||||
key = data["api_key"]
|
||||
else:
|
||||
key = secrets.token_hex(32)
|
||||
data = {"url": f"http://127.0.0.1:{port}", "api_key": key, "mode": "text-only"}
|
||||
config_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
with config_path.open("x", encoding="utf-8") as out:
|
||||
json.dump(data, out, indent=2)
|
||||
if os.name != "nt":
|
||||
config_path.chmod(0o600)
|
||||
os.environ["API_SERVER_KEY"] = key
|
||||
return key
|
||||
|
||||
|
||||
def restricted_adapter_class(native_class, tools_config):
|
||||
original_tools = tools_config._get_platform_tools
|
||||
def without_remote_tools(config, platform, **kwargs):
|
||||
if platform == "api_server":
|
||||
return set()
|
||||
return original_tools(config, platform, **kwargs)
|
||||
tools_config._get_platform_tools = without_remote_tools
|
||||
|
||||
class RestrictedNativeAPI(native_class):
|
||||
def _wire_plugin_handlers(self, app):
|
||||
# Native connect() normally appends plugin HTTP handlers after the
|
||||
# route table. Do not let that reopen the restricted companion API.
|
||||
return None
|
||||
|
||||
def _create_agent(self, *args, **kwargs):
|
||||
agent = super()._create_agent(*args, **kwargs)
|
||||
# Model/tool construction is native. Fail BEFORE run_conversation if
|
||||
# any plugin/recovery path silently reintroduced tools.
|
||||
if getattr(agent, "tools", None) or getattr(agent, "valid_tool_names", None):
|
||||
raise RuntimeError("text-only relay listener refuses an Agent with tools")
|
||||
return agent
|
||||
|
||||
def _http_route_table(self):
|
||||
allowed = {("GET", "/health"), ("GET", "/v1/models"),
|
||||
("GET", "/v1/capabilities"), ("POST", "/v1/chat/completions")}
|
||||
return [(method, path, handler) for method, path, handler in super()._http_route_table()
|
||||
if (method, path) in allowed]
|
||||
|
||||
async def _handle_capabilities(self, request):
|
||||
response = await super()._handle_capabilities(request)
|
||||
data = json.loads(response.body)
|
||||
data["hainuo_relay_policy"] = {"mode": "text-only", "tools": "disabled", "contract": "hainuo-1065-v1"}
|
||||
# Do not advertise native admin/session/tool operations removed above.
|
||||
endpoints = data.get("endpoints", {})
|
||||
data["endpoints"] = {k: v for k, v in endpoints.items() if k in {"health", "models", "capabilities", "chat_completions"}}
|
||||
data["features"] = {"text_only": True, "tools": False, "streaming": False}
|
||||
from aiohttp import web
|
||||
return web.json_response(data)
|
||||
|
||||
return RestrictedNativeAPI
|
||||
|
||||
|
||||
async def serve_native(port, key):
|
||||
from gateway.config import PlatformConfig
|
||||
from gateway.platforms.api_server import APIServerAdapter
|
||||
from hermes_cli import tools_config
|
||||
adapter_class = restricted_adapter_class(APIServerAdapter, tools_config)
|
||||
adapter = adapter_class(PlatformConfig(enabled=True, extra={"host": "127.0.0.1", "port": port,
|
||||
"key": key, "model_name": "hainuo-relay-text"}))
|
||||
try:
|
||||
if not await adapter.connect():
|
||||
raise RuntimeError("native API did not start; verify port and native installation")
|
||||
print(f"海诺原生API已启动:http://127.0.0.1:{port}(纯文本,无工具;凭据未回显)", flush=True)
|
||||
await asyncio.Event().wait()
|
||||
finally:
|
||||
await adapter.disconnect()
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--install-root", type=Path, required=True)
|
||||
parser.add_argument("--profile", default="hainuo")
|
||||
parser.add_argument("--port", type=int, default=8643)
|
||||
parser.add_argument("--config", type=Path, required=True)
|
||||
args = parser.parse_args()
|
||||
if not 1024 <= args.port <= 65535:
|
||||
raise ValueError("invalid port")
|
||||
# Native logs can contain provider/user content; this companion emits status only.
|
||||
logging.disable(logging.CRITICAL)
|
||||
key = prepare_environment(args.install_root.resolve(), args.profile, args.port, args.config.resolve())
|
||||
try:
|
||||
asyncio.run(serve_native(args.port, key))
|
||||
except KeyboardInterrupt:
|
||||
print("海诺原生API已停止。")
|
||||
except Exception as error:
|
||||
print(f"原生API启动失败({type(error).__name__});未输出凭据。请使用安装包自带Python,并核对安装根目录与Profile。", file=sys.stderr)
|
||||
raise SystemExit(1) from None
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,32 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")/.."
|
||||
test -f .env || { echo 'Run inside the existing deployment; .env missing.'; exit 1; }
|
||||
test -d wheelhouse || { echo 'Existing offline wheelhouse missing.'; exit 1; }
|
||||
backup_tag="hainuo-relay:before-h5-$(date +%Y%m%d-%H%M%S)"
|
||||
docker image tag hainuo-relay:0.1.0 "$backup_tag"
|
||||
echo "Rollback image: $backup_tag"
|
||||
# Offline dependencies are unchanged; do not pull images or initialize a new database.
|
||||
docker build --network none --pull=false -f Dockerfile.offline -t hainuo-relay:0.1.0 .
|
||||
cat > compose.h5.yaml <<'YAML'
|
||||
services:
|
||||
connector:
|
||||
environment:
|
||||
HN_REQUEST_TIMEOUT: "180"
|
||||
YAML
|
||||
args=(-f compose.yaml -f compose.offline.yaml)
|
||||
if [ -f compose.edge-fix.yaml ]; then args+=(-f compose.edge-fix.yaml); fi
|
||||
args+=(-f compose.h5.yaml)
|
||||
docker compose "${args[@]}" config --quiet
|
||||
docker compose "${args[@]}" up -d --no-build --pull never --no-deps --force-recreate connector
|
||||
for attempt in {1..30}; do
|
||||
if docker compose "${args[@]}" exec -T connector python -c \
|
||||
"import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/ready',timeout=2)" 2>/dev/null; then
|
||||
docker compose "${args[@]}" exec -T connector python -c \
|
||||
"import urllib.request; t=urllib.request.urlopen('http://127.0.0.1:8000/h5').read(); assert b'pair-form' in t; print('H5 pairing/chat revision is ready')"
|
||||
exit 0
|
||||
fi
|
||||
sleep 2
|
||||
done
|
||||
echo 'Connector not ready. Read: sudo docker compose logs --tail 80 connector'
|
||||
exit 1
|
||||
@@ -0,0 +1,116 @@
|
||||
import asyncio
|
||||
import contextlib
|
||||
import json
|
||||
import socket
|
||||
|
||||
import fakeredis.aioredis
|
||||
import httpx
|
||||
import pytest_asyncio
|
||||
import uvicorn
|
||||
|
||||
from relay.cli import device_request, init_project, issue
|
||||
from relay.config import Settings
|
||||
from relay.connector import create_app as connector_app
|
||||
from relay.router import create_app as router_app
|
||||
|
||||
|
||||
class PlatformStub:
|
||||
def __init__(self):
|
||||
self.replies = []
|
||||
self.exchanges = 0
|
||||
self.refreshes = 0
|
||||
|
||||
async def exchange(self, code):
|
||||
self.exchanges += 1
|
||||
await asyncio.sleep(0.01)
|
||||
return {"user_access_token": "fake-user-token", "refresh_token": "fake-refresh-token",
|
||||
"expires_in": 6900, "refresh_expires_in": 2592000, "open_id": "ou_test"}
|
||||
|
||||
async def refresh(self, token):
|
||||
self.refreshes += 1
|
||||
await asyncio.sleep(0.01)
|
||||
return {"user_access_token": "new-fake-token", "refresh_token": "rotated-fake-token",
|
||||
"expires_in": 7200, "open_id": "ou_test"}
|
||||
|
||||
async def user_info(self, token):
|
||||
return {"open_id": "ou_test"}
|
||||
|
||||
async def reply(self, message, text):
|
||||
self.replies.append((message, text))
|
||||
|
||||
async def close(self):
|
||||
pass
|
||||
|
||||
|
||||
async def serve(app):
|
||||
sock = socket.socket()
|
||||
sock.bind(("127.0.0.1", 0))
|
||||
sock.listen(128)
|
||||
port = sock.getsockname()[1]
|
||||
server = uvicorn.Server(uvicorn.Config(app, log_level="critical", access_log=False, lifespan="on"))
|
||||
task = asyncio.create_task(server.serve(sockets=[sock]))
|
||||
for _ in range(200):
|
||||
if server.started:
|
||||
return server, task, port
|
||||
if task.done():
|
||||
task.result()
|
||||
raise RuntimeError("server failed")
|
||||
await asyncio.sleep(0.01)
|
||||
raise RuntimeError("server startup timeout")
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def env(tmp_path):
|
||||
init_project(tmp_path, "localhost")
|
||||
settings = Settings(environment="test", admin_secret="a" * 40, internal_secret="b" * 40,
|
||||
data_dir=tmp_path / "runtime/connector", ca_cert=tmp_path / "runtime/trust/ca.pem",
|
||||
connector_key=tmp_path / "runtime/connector/connector.key",
|
||||
connector_public_key=tmp_path / "runtime/trust/connector.pub",
|
||||
feishu_enabled=True, feishu_app_id="cli_test", feishu_app_secret="fake-app-secret",
|
||||
feishu_encrypt_key="fake-encrypt-key", feishu_verification_token="fake-verification",
|
||||
public_url="http://localhost", router_url="ws://localhost/device/ws", request_timeout=2)
|
||||
redis = fakeredis.aioredis.FakeRedis(decode_responses=True)
|
||||
platform = PlatformStub()
|
||||
connector = connector_app(settings, redis=redis, platform=platform)
|
||||
router = router_app(settings, redis=redis)
|
||||
cs, ct, cp = await serve(connector)
|
||||
rs, rt, rp = await serve(router)
|
||||
client = httpx.AsyncClient(base_url=f"http://127.0.0.1:{cp}", timeout=10)
|
||||
state = {"settings": settings, "redis": redis, "platform": platform, "connector": connector,
|
||||
"router": router, "client": client, "root": tmp_path,
|
||||
"connector_url": f"http://127.0.0.1:{cp}", "router_url": f"ws://127.0.0.1:{rp}/device/ws",
|
||||
"admin": {"X-Admin-Secret": settings.admin_secret}, "tasks": []}
|
||||
yield state
|
||||
for task in state["tasks"]:
|
||||
task.cancel()
|
||||
await asyncio.gather(*state["tasks"], return_exceptions=True)
|
||||
await client.aclose()
|
||||
cs.should_exit = rs.should_exit = True
|
||||
await asyncio.wait_for(asyncio.gather(ct, rt), timeout=10)
|
||||
await redis.aclose()
|
||||
|
||||
|
||||
async def provision(env, owner="ou_test"):
|
||||
directory = env["root"] / owner
|
||||
device_request(directory)
|
||||
output = env["root"] / (owner + "-issued")
|
||||
issue(env["root"], directory / "request.json", output)
|
||||
for name in ["device.pem", "ca.pem", "connector.pub", "device.json"]:
|
||||
(directory / name).write_bytes((output / name).read_bytes())
|
||||
registration = json.loads((output / "registration.json").read_text())
|
||||
response = await env["client"].post("/admin/devices", json=registration, headers=env["admin"])
|
||||
assert response.status_code == 201, response.text
|
||||
response = await env["client"].post("/admin/test/binding-code", json={"open_id": owner, "text": "ignored"}, headers=env["admin"])
|
||||
code = response.json()["message"].split(":")[-1]
|
||||
from relay.device import bind_device
|
||||
await bind_device(directory, env["connector_url"], code)
|
||||
return directory, registration["host_id"]
|
||||
|
||||
|
||||
async def connect_device(env, directory, root=None):
|
||||
from relay.device import run_device
|
||||
connected = asyncio.Event()
|
||||
task = asyncio.create_task(run_device(directory, env["router_url"], root=root, connected_event=connected))
|
||||
env["tasks"].append(task)
|
||||
await asyncio.wait_for(connected.wait(), 5)
|
||||
return task
|
||||
@@ -0,0 +1,24 @@
|
||||
import json
|
||||
import httpx
|
||||
import pytest
|
||||
from relay.device import LocalAgent
|
||||
|
||||
|
||||
async def test_local_agent_contract_and_no_redirect():
|
||||
requests = []
|
||||
def handler(request):
|
||||
requests.append(json.loads(request.content))
|
||||
return httpx.Response(200, json={"result": "本机助手结果"})
|
||||
agent = LocalAgent("http://127.0.0.1:8765/relay/read-only", transport=httpx.MockTransport(handler))
|
||||
assert await agent.execute("整理测试文件", "ou_test", "turn") == "本机助手结果"
|
||||
assert requests[0] == {"text": "整理测试文件", "open_id": "ou_test", "turn_id": "turn", "channel": "im", "read_only": True}
|
||||
await agent.close()
|
||||
agent = LocalAgent("http://127.0.0.1:8765/relay/read-only", transport=httpx.MockTransport(
|
||||
lambda request: httpx.Response(302, headers={"Location": "https://evil.invalid"})))
|
||||
assert "未返回成功" in await agent.execute("text", "owner", "turn")
|
||||
await agent.close()
|
||||
|
||||
|
||||
def test_agent_rejects_nonlocal_endpoint():
|
||||
with pytest.raises(ValueError):
|
||||
LocalAgent("https://external.example.invalid/run")
|
||||
@@ -0,0 +1,141 @@
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
|
||||
import pytest
|
||||
from cryptography.hazmat.primitives import padding
|
||||
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
|
||||
from websockets.asyncio.client import connect
|
||||
|
||||
from relay.crypto import load_private, sign
|
||||
from relay.device import DeviceJournal
|
||||
from relay.config import Settings
|
||||
from .conftest import provision, connect_device
|
||||
from .test_integration import dispatch, event
|
||||
|
||||
|
||||
async def test_expired_and_capacity_oauth(env):
|
||||
client = env["client"]
|
||||
data = (await client.post("/oauth/start", json={})).json()
|
||||
env["connector"].state.oauth.pending[data["state"]].expires = time.monotonic() - 1
|
||||
assert (await client.get("/oauth/cb", params={"state": data["state"], "code": "x"})).status_code == 400
|
||||
env["settings"].max_pending = 1
|
||||
assert (await client.post("/oauth/start", json={})).status_code == 201
|
||||
assert (await client.post("/oauth/start", json={})).status_code == 503
|
||||
|
||||
|
||||
async def test_binding_wrong_signature_does_not_consume(env):
|
||||
# Provision one device but remove initial binding to exercise a second code.
|
||||
directory, host = await provision(env)
|
||||
env["connector"].state.store.unbind("ou_test")
|
||||
response = await env["client"].post("/admin/test/binding-code", headers=env["admin"],
|
||||
json={"open_id": "ou_test", "text": "ignored"})
|
||||
code = response.json()["message"].split(":")[-1]
|
||||
proof = sign({"host_id": host, "code": code, "ts": int(time.time())}, load_private(directory / "device.key"))
|
||||
damaged = {**proof, "signature": "AAAA"}
|
||||
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": damaged})).status_code == 403
|
||||
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": proof})).status_code == 200
|
||||
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": proof})).status_code == 404
|
||||
|
||||
|
||||
async def test_timeout_is_unknown_and_cannot_reexecute(env):
|
||||
directory, host = await provision(env)
|
||||
# A live session is required: pause reply processing to reproduce an ambiguous result.
|
||||
await connect_device(env, directory)
|
||||
env["connector"].state.reply_task.cancel()
|
||||
await asyncio.sleep(0)
|
||||
result = await dispatch(env, "ou_test", "/回显 delayed", "timeout-turn")
|
||||
assert result.json()["status"] == "unknown"
|
||||
assert (await dispatch(env, "ou_test", "/回显 retried", "timeout-turn")).json()["status"] == "duplicate"
|
||||
assert (await env["client"].get("/ready")).status_code == 503
|
||||
|
||||
|
||||
async def test_duplicate_device_connection_rejected(env):
|
||||
from relay.crypto import raw_public
|
||||
from cryptography.hazmat.primitives.asymmetric import x25519
|
||||
directory, host = await provision(env)
|
||||
await connect_device(env, directory)
|
||||
async with connect(env["router_url"], proxy=None) as ws:
|
||||
challenge = json.loads(await ws.recv())["challenge"]
|
||||
proof = sign({"host_id": host, "session_id": secrets.token_hex(16), "challenge": challenge,
|
||||
"kx": raw_public(x25519.X25519PrivateKey.generate().public_key()), "ts": int(time.time())},
|
||||
load_private(directory / "device.key"))
|
||||
await ws.send(json.dumps({"host_id": host, "cert": (directory / "device.pem").read_text(), "proof": proof}))
|
||||
from websockets.exceptions import ConnectionClosed
|
||||
with pytest.raises(ConnectionClosed):
|
||||
await ws.recv()
|
||||
assert (await dispatch(env, "ou_test", "/回显 original")).json()["result"] == "original"
|
||||
|
||||
|
||||
async def test_encrypted_webhook_and_stale_signature(env):
|
||||
directory, _ = await provision(env)
|
||||
await connect_device(env, directory)
|
||||
s = env["settings"]
|
||||
raw_event = json.dumps(event(env, "om_encrypted"), ensure_ascii=False).encode()
|
||||
pad = padding.PKCS7(128).padder()
|
||||
padded = pad.update(raw_event) + pad.finalize()
|
||||
iv = secrets.token_bytes(16)
|
||||
enc = Cipher(algorithms.AES(hashlib.sha256(s.feishu_encrypt_key.encode()).digest()), modes.CBC(iv)).encryptor()
|
||||
import base64
|
||||
raw = json.dumps({"encrypt": base64.b64encode(iv + enc.update(padded) + enc.finalize()).decode()}).encode()
|
||||
timestamp, nonce = str(int(time.time())), "encrypted-nonce"
|
||||
headers = {"X-Lark-Request-Timestamp": timestamp, "X-Lark-Request-Nonce": nonce,
|
||||
"X-Lark-Signature": hashlib.sha256((timestamp + nonce + s.feishu_encrypt_key).encode() + raw).hexdigest()}
|
||||
assert (await env["client"].post("/feishu/event", content=raw, headers=headers)).status_code == 200
|
||||
for _ in range(100):
|
||||
if env["platform"].replies:
|
||||
break
|
||||
await asyncio.sleep(0.01)
|
||||
assert env["platform"].replies == [("om_encrypted", "平台事件")]
|
||||
headers["X-Lark-Request-Timestamp"] = str(int(time.time()) - 600)
|
||||
assert (await env["client"].post("/feishu/event", content=raw, headers=headers)).status_code == 403
|
||||
|
||||
|
||||
async def test_h5_and_whoami_only_returns_owned_static_domain(env):
|
||||
await provision(env)
|
||||
env["settings"].device_domain = "pc.example.invalid"
|
||||
response = await env["client"].get("/h5")
|
||||
assert response.status_code == 200
|
||||
assert "script-src 'self'" in response.headers["content-security-policy"]
|
||||
assert (await env["client"].get("/assets/app.js")).status_code == 200
|
||||
assert (await env["client"].get("/api/whoami")).status_code == 401
|
||||
response = await env["client"].get("/api/whoami?target=https://evil.invalid", headers={"Authorization": "Bearer fake-user"})
|
||||
assert response.status_code == 200
|
||||
assert response.json()["url"].endswith(".pc.example.invalid/")
|
||||
assert response.json()["device_login_required"] is True
|
||||
|
||||
|
||||
async def test_proxy_blocks_auth_endpoints_absolute_urls_and_traversal(env):
|
||||
env["settings"].proxy_enabled = True
|
||||
for target in ["https://evil.invalid/", "//evil.invalid/", "/open-apis/auth/v3/tenant_access_token/internal",
|
||||
"/open-apis/authen/v1/user_info", "/open-apis/drive/v1/files/%2e%2e/auth", "/open-apis/drive/v1/files%0d%0aX:evil"]:
|
||||
result = await env["client"].get("/proxy", headers={"Authorization": "Bearer fake-user", "X-Relay-Target": target})
|
||||
assert result.status_code == 403, target
|
||||
|
||||
|
||||
def test_device_journal_survives_restart(tmp_path):
|
||||
path = tmp_path / "journal.sqlite"
|
||||
journal = DeviceJournal(path)
|
||||
assert journal.consume("turn")
|
||||
journal.close()
|
||||
journal = DeviceJournal(path)
|
||||
assert not journal.consume("turn")
|
||||
journal.close()
|
||||
|
||||
|
||||
def test_production_fails_closed():
|
||||
with pytest.raises(ValueError):
|
||||
Settings(environment="production", admin_secret="short", internal_secret="short")
|
||||
with pytest.raises(ValueError):
|
||||
Settings(environment="production", admin_secret="a" * 40, internal_secret="b" * 40,
|
||||
public_url="http://localhost")
|
||||
|
||||
|
||||
async def test_validation_errors_do_not_echo_tokens(env):
|
||||
token = "fake-confidential-token-" * 300
|
||||
response = await env["client"].post("/oauth/refresh", json={"refresh_token": token})
|
||||
assert response.status_code == 422
|
||||
assert "fake-confidential" not in response.text
|
||||
assert response.json() == {"detail": "invalid request parameters"}
|
||||
@@ -0,0 +1,38 @@
|
||||
import copy
|
||||
import time
|
||||
|
||||
import pytest
|
||||
from cryptography.exceptions import InvalidSignature, InvalidTag
|
||||
from cryptography.hazmat.primitives.asymmetric import ed25519, x25519
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from relay.crypto import (issue_ca, issue_device, raw_public, seal, open_envelope, verify_device)
|
||||
|
||||
|
||||
def test_encrypted_and_authenticated():
|
||||
signer = ed25519.Ed25519PrivateKey.generate()
|
||||
recipient = x25519.X25519PrivateKey.generate()
|
||||
envelope = seal({"text": "秘密合同"}, raw_public(recipient.public_key()), signer, host_id="host", session_id="session")
|
||||
assert "秘密" not in str(envelope)
|
||||
assert open_envelope(envelope, recipient, signer.public_key(), host_id="host", session_id="session")["text"] == "秘密合同"
|
||||
damaged = copy.deepcopy(envelope)
|
||||
damaged["ciphertext"] = damaged["ciphertext"][:-4] + "AAAA"
|
||||
with pytest.raises(InvalidSignature):
|
||||
open_envelope(damaged, recipient, signer.public_key(), host_id="host", session_id="session")
|
||||
with pytest.raises(ValueError):
|
||||
open_envelope(envelope, recipient, signer.public_key(), host_id="other", session_id="session")
|
||||
# Long-term signing key alone cannot recover a recorded session's data.
|
||||
with pytest.raises(InvalidTag):
|
||||
open_envelope(envelope, x25519.X25519PrivateKey.generate(), signer.public_key(), host_id="host", session_id="session")
|
||||
|
||||
|
||||
def test_certificate_identity_and_trust():
|
||||
ca_key, ca = issue_ca()
|
||||
device = ed25519.Ed25519PrivateKey.generate()
|
||||
pem = issue_device(ca_key, ca, "a" * 32, device.public_key()).public_bytes(serialization.Encoding.PEM).decode()
|
||||
ca_pem = ca.public_bytes(serialization.Encoding.PEM)
|
||||
verify_device(pem, ca_pem, "a" * 32)
|
||||
with pytest.raises(ValueError):
|
||||
verify_device(pem, ca_pem, "b" * 32)
|
||||
_, other_ca = issue_ca()
|
||||
with pytest.raises((ValueError, InvalidSignature)):
|
||||
verify_device(pem, other_ca.public_bytes(serialization.Encoding.PEM), "a" * 32)
|
||||
@@ -0,0 +1,150 @@
|
||||
import asyncio
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
from relay.hainuo1065 import Hainuo1065Agent, NativeAPIError, read_native_config
|
||||
from .conftest import provision
|
||||
from .test_integration import dispatch
|
||||
|
||||
|
||||
POLICY = {"mode": "text-only", "tools": "disabled", "contract": "hainuo-1065-v1"}
|
||||
|
||||
|
||||
def config(tmp_path, url="http://127.0.0.1:8643"):
|
||||
path = tmp_path / "native.json"
|
||||
path.write_text(json.dumps({"url": url, "api_key": "fake-local-key-" * 4, "mode": "text-only"}))
|
||||
return path
|
||||
|
||||
|
||||
def native_handler(seen, *, policy=POLICY, completion=None):
|
||||
def handler(request):
|
||||
seen.append(request)
|
||||
assert request.headers["Authorization"].startswith("Bearer fake-local-key-")
|
||||
if request.url.path == "/health":
|
||||
return httpx.Response(200, json={"status": "ok", "platform": "hermes-agent", "version": "package-fixture"})
|
||||
if request.url.path == "/v1/capabilities":
|
||||
return httpx.Response(200, json={"hainuo_relay_policy": policy})
|
||||
if request.url.path == "/v1/models":
|
||||
return httpx.Response(200, json={"data": [{"id": "hainuo-relay-text"}]})
|
||||
assert request.url.path == "/v1/chat/completions"
|
||||
return httpx.Response(200, json=completion or {"choices": [{"message": {"role": "assistant", "content": "真实API格式结果"}, "finish_reason": "stop"}]})
|
||||
return handler
|
||||
|
||||
|
||||
async def test_native_api_request_fields_idempotency_and_result(tmp_path):
|
||||
seen = []
|
||||
adapter = Hainuo1065Agent(config(tmp_path), transport=httpx.MockTransport(native_handler(seen)))
|
||||
assert await adapter.execute("只回复联调通过", "ou_a", "turn_1") == "真实API格式结果"
|
||||
post = seen[-1]
|
||||
assert json.loads(post.content) == {"model": "hainuo-relay-text", "stream": False,
|
||||
"messages": [{"role": "user", "content": "只回复联调通过"}]}
|
||||
assert post.headers["Idempotency-Key"].startswith("hn-")
|
||||
idem = post.headers["Idempotency-Key"]
|
||||
await adapter.execute("只回复联调通过", "ou_a", "turn_1")
|
||||
assert seen[-1].headers["Idempotency-Key"] == idem
|
||||
await adapter.execute("只回复联调通过", "ou_b", "turn_1")
|
||||
assert seen[-1].headers["Idempotency-Key"] != idem
|
||||
await adapter.close()
|
||||
|
||||
|
||||
async def test_refuses_stock_unrestricted_api(tmp_path):
|
||||
seen = []
|
||||
adapter = Hainuo1065Agent(config(tmp_path), transport=httpx.MockTransport(native_handler(seen, policy={})))
|
||||
result = await adapter.execute("anything", "owner", "turn")
|
||||
assert "policy missing" in result
|
||||
assert all(request.method != "POST" for request in seen)
|
||||
await adapter.close()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("completion", [
|
||||
{"choices": []},
|
||||
{"choices": [{"message": {"content": "partial"}, "finish_reason": "length"}]},
|
||||
{"choices": [{"message": {"content": "tool", "tool_calls": [{"id": "x"}]}, "finish_reason": "stop"}]},
|
||||
])
|
||||
async def test_incomplete_native_results_fail_closed(tmp_path, completion):
|
||||
adapter = Hainuo1065Agent(config(tmp_path), transport=httpx.MockTransport(native_handler([], completion=completion)))
|
||||
assert "未完成请求" in await adapter.execute("anything", "owner", "turn")
|
||||
await adapter.close()
|
||||
|
||||
|
||||
async def test_native_redirect_no_retry_and_no_error_body_leak(tmp_path):
|
||||
seen = []
|
||||
def handler(request):
|
||||
seen.append(request)
|
||||
return httpx.Response(302, headers={"Location": "https://outside.invalid/"}, text="fake-confidential-body")
|
||||
adapter = Hainuo1065Agent(config(tmp_path), transport=httpx.MockTransport(handler))
|
||||
result = await adapter.execute("anything", "owner", "turn")
|
||||
assert "fake-confidential" not in result and "HTTP 302" in result
|
||||
assert len(seen) == 1
|
||||
await adapter.close()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("url", ["http://example.invalid:8643", "http://localhost:8643", "https://127.0.0.1:8643", "http://127.0.0.1:8643/p/other", "http://user:pass@127.0.0.1:8643"])
|
||||
def test_native_target_cannot_be_remote_or_profile_switched(tmp_path, url):
|
||||
with pytest.raises(ValueError):
|
||||
read_native_config(config(tmp_path, url))
|
||||
|
||||
|
||||
def test_native_launcher_enforces_no_tools_and_endpoint_whitelist():
|
||||
script = Path(__file__).resolve().parents[1] / "scripts/hainuo_native_api.py"
|
||||
spec = importlib.util.spec_from_file_location("native_launcher_test", script)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
class Native:
|
||||
def _create_agent(self):
|
||||
return SimpleNamespace(tools=[{"name": "terminal"}], valid_tool_names={"terminal"})
|
||||
def _http_route_table(self):
|
||||
return [("GET", "/health", None), ("POST", "/v1/chat/completions", None),
|
||||
("DELETE", "/api/sessions/x", None), ("POST", "/api/jobs", None)]
|
||||
tools = SimpleNamespace(_get_platform_tools=lambda config, platform, **kwargs: {"terminal"})
|
||||
Restricted = module.restricted_adapter_class(Native, tools)
|
||||
assert tools._get_platform_tools({}, "api_server") == set()
|
||||
assert tools._get_platform_tools({}, "feishu") == {"terminal"}
|
||||
assert len(Restricted()._http_route_table()) == 2
|
||||
assert Restricted()._wire_plugin_handlers(object()) is None
|
||||
with pytest.raises(RuntimeError, match="refuses an Agent with tools"):
|
||||
Restricted()._create_agent()
|
||||
|
||||
|
||||
async def test_encrypted_ecs_device_native_http_and_return(env):
|
||||
"""Real socket chain; native API is a contract fixture, not installed Hermes."""
|
||||
from fastapi import FastAPI, Request
|
||||
from .conftest import serve
|
||||
from relay.device import run_device
|
||||
app = FastAPI()
|
||||
seen = []
|
||||
@app.get("/health")
|
||||
async def health():
|
||||
return {"status": "ok", "platform": "hermes-agent", "version": "contract-fixture"}
|
||||
@app.get("/v1/capabilities")
|
||||
async def capabilities():
|
||||
return {"hainuo_relay_policy": POLICY}
|
||||
@app.get("/v1/models")
|
||||
async def models():
|
||||
return {"data": [{"id": "hainuo-relay-text"}]}
|
||||
@app.post("/v1/chat/completions")
|
||||
async def chat(request: Request):
|
||||
seen.append(await request.json())
|
||||
assert request.headers.get("Idempotency-Key")
|
||||
return {"choices": [{"message": {"content": "本机API对接成功"}, "finish_reason": "stop"}]}
|
||||
server, server_task, port = await serve(app)
|
||||
directory, _ = await provision(env)
|
||||
cfg = config(env["root"], f"http://127.0.0.1:{port}")
|
||||
connected = asyncio.Event()
|
||||
device = asyncio.create_task(run_device(directory, env["router_url"], connected_event=connected, hainuo_config=cfg))
|
||||
env["tasks"].append(device)
|
||||
try:
|
||||
await asyncio.wait_for(connected.wait(), 5)
|
||||
response = await dispatch(env, "ou_test", "/助手 只回复本机API对接成功", "native-turn")
|
||||
assert response.json()["result"] == "本机API对接成功"
|
||||
assert seen[0]["messages"][0]["content"] == "只回复本机API对接成功"
|
||||
assert (await dispatch(env, "ou_test", "/助手 repeat", "native-turn")).json()["status"] == "duplicate"
|
||||
assert len(seen) == 1
|
||||
finally:
|
||||
server.should_exit = True
|
||||
await asyncio.wait_for(server_task, 5)
|
||||
@@ -0,0 +1,38 @@
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
import tarfile
|
||||
|
||||
from scripts.fetch_official_images import export_image, digest_file
|
||||
|
||||
|
||||
def test_offline_docker_archive_preserves_config_and_rootfs(tmp_path):
|
||||
cache, output = tmp_path / "cache", tmp_path / "out"
|
||||
cache.mkdir()
|
||||
output.mkdir()
|
||||
layer = io.BytesIO()
|
||||
with tarfile.open(fileobj=layer, mode="w") as tar:
|
||||
content = b"hello ARM64\n"
|
||||
info = tarfile.TarInfo("test.txt")
|
||||
info.size, info.mode = len(content), 0o644
|
||||
tar.addfile(info, io.BytesIO(content))
|
||||
raw = layer.getvalue()
|
||||
raw_digest = hashlib.sha256(raw).hexdigest()
|
||||
import gzip
|
||||
compressed = gzip.compress(raw)
|
||||
blob_digest = hashlib.sha256(compressed).hexdigest()
|
||||
(cache / (blob_digest + ".blob")).write_bytes(compressed)
|
||||
config = json.dumps({"architecture": "arm64", "os": "linux", "config": {"Env": []},
|
||||
"rootfs": {"type": "layers", "diff_ids": ["sha256:" + raw_digest]}}).encode()
|
||||
config_digest = hashlib.sha256(config).hexdigest()
|
||||
(cache / (config_digest + ".blob")).write_bytes(config)
|
||||
record = {"name": "test", "tag": "arm64", "config": {"digest": "sha256:" + config_digest},
|
||||
"layers": [{"digest": "sha256:" + blob_digest}]}
|
||||
export_image(record, cache, output)
|
||||
path = output / record["archive"]
|
||||
assert record["archive_sha256"] == digest_file(path)
|
||||
with tarfile.open(path) as tar:
|
||||
manifest = json.load(tar.extractfile("manifest.json"))[0]
|
||||
assert manifest["RepoTags"] == ["test:arm64"]
|
||||
assert tar.extractfile(manifest["Config"]).read() == config
|
||||
assert tar.extractfile(manifest["Layers"][0]).read() == raw
|
||||
@@ -0,0 +1,143 @@
|
||||
import asyncio
|
||||
import hashlib
|
||||
import json
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from relay.crypto import load_private, sign
|
||||
from .conftest import provision, connect_device
|
||||
|
||||
|
||||
async def dispatch(env, owner, text, turn=None):
|
||||
return await env["client"].post("/admin/test/dispatch", headers=env["admin"],
|
||||
json={"open_id": owner, "text": text, "turn_id": turn or uuid.uuid4().hex})
|
||||
|
||||
|
||||
async def test_two_devices_encrypted_isolation_and_dedup(env):
|
||||
a, ah = await provision(env, "ou_a")
|
||||
b, bh = await provision(env, "ou_b")
|
||||
await connect_device(env, a)
|
||||
await connect_device(env, b)
|
||||
responses = await asyncio.gather(dispatch(env, "ou_a", "/回显 A的唯一结果"), dispatch(env, "ou_b", "/回显 B的唯一结果"))
|
||||
assert [x.json()["result"] for x in responses] == ["A的唯一结果", "B的唯一结果"]
|
||||
first = await dispatch(env, "ou_a", "/回显 once", "same-turn")
|
||||
again = await dispatch(env, "ou_a", "/回显 twice", "same-turn")
|
||||
assert first.json()["status"] == "completed"
|
||||
assert again.json()["status"] == "duplicate"
|
||||
# Directory compromise cannot silently substitute B's certificate for A.
|
||||
presence_b = await env["redis"].get("hn:online:" + bh)
|
||||
await env["redis"].set("hn:online:" + ah, presence_b)
|
||||
assert (await dispatch(env, "ou_a", "/回显 leaked")).status_code == 409
|
||||
|
||||
|
||||
async def test_offline_revoke_and_persistence(env):
|
||||
directory, host = await provision(env)
|
||||
assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "offline"
|
||||
await connect_device(env, directory)
|
||||
assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "completed"
|
||||
result = await env["client"].post(f"/admin/devices/{host}/revoke", headers=env["admin"])
|
||||
assert result.status_code == 200
|
||||
assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "unavailable"
|
||||
await asyncio.sleep(0.05)
|
||||
assert not await env["redis"].exists("hn:online:" + host)
|
||||
from relay.store import Store
|
||||
db = Store(env["settings"].data_dir / "metadata.sqlite")
|
||||
assert db.device(host)["revoked"] == 1
|
||||
db.close()
|
||||
|
||||
|
||||
async def test_device_read_boundary(env):
|
||||
directory, host = await provision(env)
|
||||
root = env["root"] / "test-files"
|
||||
root.mkdir()
|
||||
(root / "allowed.txt").write_text("授权内容", encoding="utf-8")
|
||||
(env["root"] / "outside.txt").write_text("不该读到", encoding="utf-8")
|
||||
await connect_device(env, directory, root)
|
||||
assert (await dispatch(env, "ou_test", "/读取 allowed.txt")).json()["result"] == "授权内容"
|
||||
assert "拒绝" in (await dispatch(env, "ou_test", "/读取 ../outside.txt")).json()["result"]
|
||||
assert "只读诊断" in (await dispatch(env, "ou_test", "rm -rf /")).json()["result"]
|
||||
|
||||
|
||||
async def test_binding_requires_device_proof_and_one_time_code(env):
|
||||
directory, host = await provision(env)
|
||||
response = await env["client"].post("/device/bind", json={"host_id": host, "proof": {}})
|
||||
assert response.status_code == 403
|
||||
response = await env["client"].post("/admin/devices", json={"host_id": host, "cert": "invalid"})
|
||||
assert response.status_code == 401
|
||||
|
||||
|
||||
async def test_oauth_wrong_secret_does_not_destroy_and_claim_once(env):
|
||||
client = env["client"]
|
||||
start = await client.post("/oauth/start?state=attacker", json={})
|
||||
assert start.status_code == 201
|
||||
data = start.json()
|
||||
assert data["state"] != "attacker"
|
||||
assert data["claim_secret"] not in data["authorization_url"]
|
||||
cb = await client.get("/oauth/cb", params={"state": data["state"], "code": "fake-code"})
|
||||
assert cb.status_code == 200
|
||||
bad = await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": "bad"})
|
||||
assert bad.status_code == 404
|
||||
good = await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]})
|
||||
assert good.status_code == 200
|
||||
assert good.json()["expires_in"] == 6900
|
||||
assert "code" not in good.json()
|
||||
assert good.headers["cache-control"] == "no-store"
|
||||
assert (await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]})).status_code == 404
|
||||
assert (await client.get("/oauth/cb?state=unknown&code=x")).status_code == 400
|
||||
|
||||
|
||||
async def test_oauth_concurrent_callbacks_claims_and_refresh(env):
|
||||
client = env["client"]
|
||||
data = (await client.post("/oauth/start", json={})).json()
|
||||
responses = await asyncio.gather(*[client.get("/oauth/cb", params={"state": data["state"], "code": "same"}) for _ in range(2)])
|
||||
assert sorted(x.status_code for x in responses) == [200, 400]
|
||||
assert env["platform"].exchanges == 1
|
||||
responses = await asyncio.gather(*[client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]}) for _ in range(2)])
|
||||
assert sorted(x.status_code for x in responses) == [200, 404]
|
||||
responses = await asyncio.gather(*[client.post("/oauth/refresh", json={"refresh_token": "same-fake-refresh"}) for _ in range(2)])
|
||||
assert sorted(x.status_code for x in responses) == [200, 409]
|
||||
assert env["platform"].refreshes == 1
|
||||
|
||||
|
||||
async def test_body_limit_proxy_disabled_and_rate_limit(env):
|
||||
client = env["client"]
|
||||
assert (await client.post("/oauth/start", content=b"x" * 300000)).status_code == 413
|
||||
assert (await client.get("/proxy", headers={"X-Relay-Target": "https://evil.invalid"})).status_code == 404
|
||||
statuses = [(await client.post("/oauth/start", json={})).status_code for _ in range(21)]
|
||||
assert statuses[-1] == 429
|
||||
|
||||
|
||||
def event(env, message_id="om_test", text="/回显 平台事件", chat_type="p2p"):
|
||||
return {"header": {"event_type": "im.message.receive_v1", "app_id": env["settings"].feishu_app_id,
|
||||
"token": env["settings"].feishu_verification_token},
|
||||
"event": {"sender": {"sender_type": "user", "sender_id": {"open_id": "ou_test"}},
|
||||
"message": {"message_id": message_id, "chat_type": chat_type, "message_type": "text",
|
||||
"content": json.dumps({"text": text}, ensure_ascii=False)}}}
|
||||
|
||||
|
||||
async def test_webhook_signature_event_routing_and_replay(env):
|
||||
directory, _ = await provision(env)
|
||||
await connect_device(env, directory)
|
||||
raw = json.dumps(event(env), ensure_ascii=False).encode()
|
||||
timestamp, nonce = str(int(time.time())), "nonce"
|
||||
signature = hashlib.sha256((timestamp + nonce + env["settings"].feishu_encrypt_key).encode() + raw).hexdigest()
|
||||
headers = {"X-Lark-Request-Timestamp": timestamp, "X-Lark-Request-Nonce": nonce, "X-Lark-Signature": signature}
|
||||
assert (await env["client"].post("/feishu/event", content=raw)).status_code == 403
|
||||
for _ in range(2):
|
||||
assert (await env["client"].post("/feishu/event", content=raw, headers=headers)).status_code == 200
|
||||
for _ in range(100):
|
||||
if env["platform"].replies:
|
||||
break
|
||||
await asyncio.sleep(0.02)
|
||||
assert env["platform"].replies == [("om_test", "平台事件")]
|
||||
# No transcript or credentials persisted in either connector metadata or device journal.
|
||||
for db in [env["settings"].data_dir / "metadata.sqlite", directory / "journal.sqlite"]:
|
||||
assert "平台事件".encode() not in db.read_bytes()
|
||||
|
||||
|
||||
async def test_group_events_ignored(env):
|
||||
result = await env["client"].post("/internal/events", json=event(env, chat_type="group"),
|
||||
headers={"X-Internal-Secret": env["settings"].internal_secret})
|
||||
assert result.status_code == 200
|
||||
await asyncio.sleep(0.05)
|
||||
assert env["platform"].replies == []
|
||||
@@ -0,0 +1,36 @@
|
||||
import httpx
|
||||
import pytest
|
||||
from relay.platform import Feishu, PlatformError
|
||||
|
||||
|
||||
async def test_private_platform_domain_and_reply_target(env):
|
||||
seen = []
|
||||
def handler(request):
|
||||
seen.append(request)
|
||||
if request.url.path.endswith("app_access_token/internal"):
|
||||
return httpx.Response(200, json={"code": 0, "app_access_token": "fake-app-token", "expire": 7200})
|
||||
if request.url.path.endswith("tenant_access_token/internal"):
|
||||
return httpx.Response(200, json={"code": 0, "tenant_access_token": "fake-tenant-token", "expire": 7200})
|
||||
if request.url.path.endswith("oidc/access_token"):
|
||||
return httpx.Response(200, json={"code": 0, "data": {"access_token": "fake-user-token",
|
||||
"refresh_token": "fake-refresh", "expires_in": 6900, "open_id": "ou_test"}})
|
||||
return httpx.Response(200, json={"code": 0, "data": {}})
|
||||
env["settings"].feishu_api_base = "https://private.example.invalid"
|
||||
f = Feishu(env["settings"], transport=httpx.MockTransport(handler))
|
||||
result = await f.exchange("fake-code")
|
||||
assert result["expires_in"] == 6900
|
||||
await f.reply("om_original", "你好")
|
||||
assert all(x.url.host == "private.example.invalid" for x in seen)
|
||||
assert seen[-1].url.path == "/open-apis/im/v1/messages/om_original/reply"
|
||||
assert seen[-1].headers["Authorization"] == "Bearer fake-tenant-token"
|
||||
assert len([x for x in seen if x.url.path.endswith("app_access_token/internal")]) == 1
|
||||
await f.close()
|
||||
|
||||
|
||||
async def test_platform_errors_never_echo_credentials(env):
|
||||
f = Feishu(env["settings"], transport=httpx.MockTransport(
|
||||
lambda request: httpx.Response(400, text="fake-secret-that-must-not-appear")))
|
||||
with pytest.raises(PlatformError) as error:
|
||||
await f.app_token()
|
||||
assert "fake-secret" not in str(error.value)
|
||||
await f.close()
|
||||
@@ -0,0 +1,33 @@
|
||||
"""Opt-in real PostgreSQL verification in an isolated, newly created schema."""
|
||||
import os
|
||||
import uuid
|
||||
import psycopg
|
||||
import pytest
|
||||
from psycopg import sql
|
||||
from relay.store import Store
|
||||
|
||||
|
||||
@pytest.mark.skipif(not os.environ.get("HN_TEST_DATABASE_URL"), reason="real PostgreSQL URL not supplied")
|
||||
def test_postgres_metadata_and_duplicate_claim(tmp_path):
|
||||
url = os.environ["HN_TEST_DATABASE_URL"]
|
||||
schema = "hn_test_" + uuid.uuid4().hex
|
||||
conn = psycopg.connect(url, autocommit=True)
|
||||
conn.execute(sql.SQL("CREATE SCHEMA {}").format(sql.Identifier(schema)))
|
||||
from psycopg.conninfo import make_conninfo
|
||||
isolated = make_conninfo(url, options=f"-c search_path={schema}")
|
||||
store = None
|
||||
try:
|
||||
store = Store(tmp_path / "unused.sqlite", isolated)
|
||||
store.add_device("host", "cert", "fingerprint")
|
||||
store.bind("host", "owner")
|
||||
assert store.by_owner("owner")["host_id"] == "host"
|
||||
assert store.begin_turn("turn", "owner", "host")
|
||||
assert not store.begin_turn("turn", "owner", "host")
|
||||
store.audit("owner", "instruction", "host", "completed")
|
||||
store.revoke("host")
|
||||
assert not store.by_owner("owner")
|
||||
finally:
|
||||
if store:
|
||||
store.close()
|
||||
conn.execute(sql.SQL("DROP SCHEMA {} CASCADE").format(sql.Identifier(schema)))
|
||||
conn.close()
|
||||
@@ -0,0 +1,44 @@
|
||||
import asyncio
|
||||
import json
|
||||
import secrets
|
||||
|
||||
from fastapi import FastAPI
|
||||
|
||||
from relay.device import run_device
|
||||
from .conftest import provision, serve
|
||||
from .test_hainuo1065 import POLICY, config
|
||||
from .test_web_session import browser
|
||||
|
||||
|
||||
async def test_h5_cookie_to_encrypted_device_to_native_http_result(env):
|
||||
"""Real loopback HTTP + WS, with a native model contract fixture."""
|
||||
app = FastAPI()
|
||||
@app.get("/health")
|
||||
async def health():
|
||||
return {"status": "ok", "platform": "hermes-agent"}
|
||||
@app.get("/v1/capabilities")
|
||||
async def capabilities():
|
||||
return {"hainuo_relay_policy": POLICY}
|
||||
@app.get("/v1/models")
|
||||
async def models():
|
||||
return {"data": [{"id": "hainuo-relay-text"}]}
|
||||
@app.post("/v1/chat/completions")
|
||||
async def chat():
|
||||
return {"choices": [{"message": {"content": "42"}, "finish_reason": "stop"}]}
|
||||
server, task, port = await serve(app)
|
||||
directory, host = await provision(env)
|
||||
cfg = config(env["root"], f"http://127.0.0.1:{port}")
|
||||
connected = asyncio.Event()
|
||||
device = asyncio.create_task(run_device(directory, env["router_url"], connected_event=connected, hainuo_config=cfg))
|
||||
env["tasks"].append(device)
|
||||
try:
|
||||
await asyncio.wait_for(connected.wait(), 5)
|
||||
headers = await browser(env, directory, host)
|
||||
response = await env["client"].post("/web/chat", headers=headers,
|
||||
json={"text": "17加25", "request_id": secrets.token_hex(16)})
|
||||
assert response.status_code == 200
|
||||
assert response.json()["status"] == "completed"
|
||||
assert response.json()["result"] == "42"
|
||||
finally:
|
||||
server.should_exit = True
|
||||
await asyncio.wait_for(task, 5)
|
||||
@@ -0,0 +1,141 @@
|
||||
import asyncio
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
from relay.crypto import load_private, sign
|
||||
from relay.web_session import COOKIE, digest
|
||||
from .conftest import provision, connect_device
|
||||
|
||||
|
||||
async def issue(env, directory, host):
|
||||
config = json.loads((directory / "device.json").read_text())
|
||||
proof = sign({"host_id": host, "owner": config["owner"], "purpose": "h5-pair-v1",
|
||||
"nonce": secrets.token_hex(16), "ts": int(time.time())}, load_private(directory / "device.key"))
|
||||
response = await env["client"].post("/device/web-pair", json={"host_id": host, "proof": proof})
|
||||
assert response.status_code == 200, response.text
|
||||
return response.json(), proof
|
||||
|
||||
|
||||
async def claim(env, code):
|
||||
return await env["client"].post("/web/claim", json={"code": code}, headers={"Origin": env["settings"].public_url})
|
||||
|
||||
|
||||
def cookie(response):
|
||||
return {"Cookie": COOKIE + "=" + response.cookies.get(COOKIE)}
|
||||
|
||||
|
||||
async def browser(env, directory, host):
|
||||
issued, _ = await issue(env, directory, host)
|
||||
response = await claim(env, issued["code"])
|
||||
assert response.status_code == 200, response.text
|
||||
return {**cookie(response), "Origin": env["settings"].public_url}
|
||||
|
||||
|
||||
async def test_browser_pairing_one_time_signed_and_secure_cookie(env):
|
||||
directory, host = await provision(env)
|
||||
issued, proof = await issue(env, directory, host)
|
||||
assert "signature" in issued
|
||||
# The anonymous browser can neither name an owner nor invent a device signature.
|
||||
assert (await env["client"].post("/device/web-pair", json={"host_id": host, "proof": {}})).status_code == 403
|
||||
assert (await env["client"].post("/device/web-pair", json={"host_id": host, "proof": proof})).status_code == 409
|
||||
response = await claim(env, issued["code"])
|
||||
assert response.status_code == 200
|
||||
header = response.headers["set-cookie"].lower()
|
||||
assert "secure" in header and "httponly" in header and "samesite=strict" in header
|
||||
assert "code" not in response.json() and "owner" not in response.json()
|
||||
assert (await claim(env, issued["code"])).status_code == 404
|
||||
assert (await env["client"].get("/web/session")).status_code == 401 # Secure cookies never sent over test HTTP.
|
||||
session = await env["client"].get("/web/session", headers=cookie(response))
|
||||
assert session.status_code == 200 and session.json()["host_id"] == host
|
||||
assert session.headers["cache-control"] == "no-store"
|
||||
|
||||
|
||||
async def test_cross_origin_cannot_consume_pair_code_or_send_chat(env):
|
||||
directory, host = await provision(env)
|
||||
issued, _ = await issue(env, directory, host)
|
||||
for origin in [None, "https://evil.invalid", "null", "http://localhost.evil.invalid"]:
|
||||
headers = {} if origin is None else {"Origin": origin}
|
||||
result = await env["client"].post("/web/claim", json={"code": issued["code"]}, headers=headers)
|
||||
assert result.status_code == 403
|
||||
response = await claim(env, issued["code"])
|
||||
assert response.status_code == 200
|
||||
result = await env["client"].post("/web/chat", headers={**cookie(response), "Origin": "https://evil.invalid"},
|
||||
json={"text": "hello", "request_id": secrets.token_hex(16)})
|
||||
assert result.status_code == 403
|
||||
|
||||
|
||||
async def test_web_devices_are_isolated_and_chat_deduplicates(env):
|
||||
a, ah = await provision(env, "ou_a")
|
||||
b, bh = await provision(env, "ou_b")
|
||||
await connect_device(env, a)
|
||||
await connect_device(env, b)
|
||||
a_headers = await browser(env, a, ah)
|
||||
b_headers = await browser(env, b, bh)
|
||||
rid = secrets.token_hex(16)
|
||||
a_result, b_result = await asyncio.gather(
|
||||
env["client"].post("/web/chat", headers=a_headers, json={"text": "/回显 A独立回复", "request_id": rid}),
|
||||
env["client"].post("/web/chat", headers=b_headers, json={"text": "/回显 B独立回复", "request_id": rid}))
|
||||
assert a_result.json()["result"] == "A独立回复"
|
||||
assert b_result.json()["result"] == "B独立回复"
|
||||
again = await env["client"].post("/web/chat", headers=a_headers, json={"text": "/回显 repeat", "request_id": rid})
|
||||
assert again.json()["status"] == "duplicate"
|
||||
# Redis contains only pairing/session metadata, never the plaintext chat transcript.
|
||||
for key in await env["redis"].keys("hn:web*"):
|
||||
value = await env["redis"].get(key)
|
||||
assert "独立回复" not in str(value)
|
||||
|
||||
|
||||
async def test_logout_expiry_and_revoke_invalidate_browser(env):
|
||||
directory, host = await provision(env)
|
||||
headers = await browser(env, directory, host)
|
||||
assert (await env["client"].post("/web/logout", headers=headers)).status_code == 200
|
||||
assert (await env["client"].get("/web/session", headers=headers)).status_code == 401
|
||||
headers = await browser(env, directory, host)
|
||||
await env["redis"].delete("hn:web-session:" + digest(headers["Cookie"].split("=", 1)[1]))
|
||||
assert (await env["client"].get("/web/session", headers=headers)).status_code == 401
|
||||
headers = await browser(env, directory, host)
|
||||
await env["client"].post(f"/admin/devices/{host}/revoke", headers=env["admin"])
|
||||
assert (await env["client"].get("/web/session", headers=headers)).status_code == 401
|
||||
|
||||
|
||||
async def test_binding_generation_invalidates_old_codes_and_sessions(env):
|
||||
directory, host = await provision(env)
|
||||
issued, _ = await issue(env, directory, host)
|
||||
headers = await browser(env, directory, host)
|
||||
await env["redis"].incr("hn:web-generation:" + host)
|
||||
assert (await claim(env, issued["code"])).status_code == 401
|
||||
assert (await env["client"].get("/web/session", headers=headers)).status_code == 401
|
||||
|
||||
|
||||
async def test_pair_code_expiry_and_anonymous_chat_denied(env):
|
||||
directory, host = await provision(env)
|
||||
issued, _ = await issue(env, directory, host)
|
||||
await env["redis"].delete("hn:web-code:" + digest(issued["code"]))
|
||||
assert (await claim(env, issued["code"])).status_code == 404
|
||||
assert (await env["client"].post("/web/chat", headers={"Origin": env["settings"].public_url},
|
||||
json={"text": "hello", "request_id": secrets.token_hex(16)})).status_code == 401
|
||||
|
||||
|
||||
async def test_unprefixed_question_uses_native_agent_prefix(env):
|
||||
directory, host = await provision(env)
|
||||
headers = await browser(env, directory, host)
|
||||
seen = []
|
||||
async def capture(owner, text, turn):
|
||||
seen.append((owner, text))
|
||||
return {"status": "completed", "result": "42", "turn_id": turn}
|
||||
env["connector"].state.broker.dispatch = capture
|
||||
response = await env["client"].post("/web/chat", headers=headers,
|
||||
json={"text": "17加25", "request_id": secrets.token_hex(16), "open_id": "attacker"})
|
||||
assert response.json()["result"] == "42"
|
||||
assert seen == [("ou_test", "/助手 17加25")]
|
||||
|
||||
|
||||
async def test_concurrent_claim_exactly_one_browser(env):
|
||||
directory, host = await provision(env)
|
||||
issued, _ = await issue(env, directory, host)
|
||||
results = await asyncio.gather(claim(env, issued["code"]), claim(env, issued["code"]))
|
||||
assert sorted(x.status_code for x in results) == [200, 404]
|
||||
@@ -0,0 +1,10 @@
|
||||
FROM python:3.12-slim-bookworm
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1
|
||||
WORKDIR /app
|
||||
COPY wheelhouse /wheels
|
||||
COPY requirements.lock pyproject.toml ./
|
||||
COPY relay ./relay
|
||||
RUN pip install --no-index --find-links=/wheels --no-cache-dir -r requirements.lock && rm -rf /wheels
|
||||
RUN chmod -R a+rX /app
|
||||
USER 10001:10001
|
||||
ENTRYPOINT ["python", "-m", "relay.cli"]
|
||||
@@ -0,0 +1,39 @@
|
||||
services:
|
||||
connector:
|
||||
environment:
|
||||
HN_ENROLLMENT_SIGNER_URL: <REDACTED_LITERAL>
|
||||
depends_on:
|
||||
enrollment-signer:
|
||||
condition: service_healthy
|
||||
enrollment-signer:
|
||||
image: hainuo-relay:0.1.0
|
||||
entrypoint:
|
||||
- python
|
||||
- -m
|
||||
- relay.enrollment_signer
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
HN_INTERNAL_SECRET: ${HN_INTERNAL_SECRET}
|
||||
volumes:
|
||||
- ./runtime/issuer:/issuer:ro
|
||||
- ./runtime/trust:/trust:ro
|
||||
networks:
|
||||
- backend
|
||||
read_only: true
|
||||
tmpfs:
|
||||
- /tmp:size=16m,noexec,nosuid
|
||||
cap_drop:
|
||||
- ALL
|
||||
security_opt:
|
||||
- no-new-privileges:true
|
||||
mem_limit: 128m
|
||||
healthcheck:
|
||||
test:
|
||||
- CMD
|
||||
- python
|
||||
- -c
|
||||
- import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/ready',
|
||||
timeout=3)
|
||||
interval: 10s
|
||||
timeout: 5s
|
||||
retries: 5
|
||||
@@ -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,284 @@
|
||||
"""Per-user Windows connection companion. No platform/application secrets."""
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import socket
|
||||
import ssl
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
import psutil
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
|
||||
from .crypto import load_private, load_public, pem_private, raw_public, sign, verified, verify_device
|
||||
from .windows_keys import protect
|
||||
|
||||
BASE = Path(__file__).resolve().parent.parent
|
||||
URL = "https://10.77.76.13"
|
||||
|
||||
|
||||
def save(path, value):
|
||||
temp = path.with_suffix(path.suffix + ".tmp")
|
||||
temp.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
os.replace(temp, path)
|
||||
|
||||
|
||||
def secure_directory(directory):
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
# SID avoids localized account names. Fail closed if ACL protection fails.
|
||||
result = subprocess.run(["whoami", "/user", "/fo", "csv", "/nh"], capture_output=True, text=True, check=True)
|
||||
import csv
|
||||
sid = list(csv.reader([result.stdout.strip()]))[0][1]
|
||||
subprocess.run(["icacls", str(directory), "/inheritance:r", "/grant:r", f"*{sid}:(OI)(CI)F", "*S-1-5-18:(OI)(CI)F"],
|
||||
capture_output=True, check=True, creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
|
||||
|
||||
def prepare(directory):
|
||||
secure_directory(directory)
|
||||
for name in ("server.pem", "ca.pem", "connector.pub"):
|
||||
target = directory / name
|
||||
if not target.exists():
|
||||
target.write_bytes((BASE / "trust" / name).read_bytes())
|
||||
if not (directory / "device.json").exists():
|
||||
if (directory / "device.key.dpapi").exists() or (directory / "device.key").exists():
|
||||
raise RuntimeError("发现不完整的设备身份,请保留目录并联系管理员恢复。")
|
||||
private = Ed25519PrivateKey.generate()
|
||||
(directory / "device.key.dpapi").write_bytes(protect(pem_private(private)))
|
||||
save(directory / "device.json", {"host_id": uuid.uuid4().hex, "owner": None})
|
||||
|
||||
|
||||
def tls(directory):
|
||||
return ssl.create_default_context(cafile=str(directory / "server.pem"))
|
||||
|
||||
|
||||
def import_existing(directory, source):
|
||||
"""Explicit migration; only public trust and this PC's identity, never app keys."""
|
||||
if source.resolve() == directory.resolve():
|
||||
raise ValueError("请选择旧设备目录。")
|
||||
if any((directory / name).exists() for name in ("device.json", "device.key.dpapi", "device.key")):
|
||||
raise RuntimeError("本目录已有设备身份。请使用已有身份继续,不能用导入覆盖。")
|
||||
config = json.loads((source / "device.json").read_text(encoding="utf-8-sig"))
|
||||
for name in ("server.pem", "ca.pem", "connector.pub"):
|
||||
if (source / name).read_bytes().strip() != (BASE / "trust" / name).read_bytes().strip():
|
||||
raise ValueError("旧设备的服务信任与本安装包不符,请联系管理员。")
|
||||
cert = (source / "device.pem").read_text(encoding="utf-8")
|
||||
public = verify_device(cert, (source / "ca.pem").read_bytes(), config["host_id"])
|
||||
private = load_private(source / "device.key")
|
||||
if raw_public(public) != raw_public(private.public_key()):
|
||||
raise ValueError("设备证书与本机私钥不匹配。")
|
||||
secure_directory(directory)
|
||||
for name in ("device.pem", "server.pem", "ca.pem", "connector.pub"):
|
||||
(directory / name).write_bytes((source / name).read_bytes())
|
||||
(directory / "device.key.dpapi").write_bytes(protect(pem_private(private)))
|
||||
save(directory / "device.json", config)
|
||||
# Preserve local replay journal using SQLite's consistent backup API.
|
||||
if (source / "journal.sqlite").is_file():
|
||||
import sqlite3
|
||||
with sqlite3.connect(source / "journal.sqlite") as original, sqlite3.connect(directory / "journal.sqlite") as target:
|
||||
original.backup(target)
|
||||
return {"message": "旧设备导入成功,Work绑定已保留。请先停止旧PowerShell桥接窗口,再点击启动连接。"}
|
||||
|
||||
|
||||
def enrollment(directory):
|
||||
prepare(directory)
|
||||
cfg = json.loads((directory / "device.json").read_text())
|
||||
if (directory / "device.pem").exists():
|
||||
verify_device((directory / "device.pem").read_text(), (directory / "ca.pem").read_bytes(), cfg["host_id"])
|
||||
return {"message": "设备已注册,可在Work获取绑定码后绑定。已有绑定可直接启动连接。"}
|
||||
with httpx.Client(verify=tls(directory), trust_env=False, timeout=15) as http:
|
||||
key = load_private(directory / "device.key")
|
||||
proof = sign({"host_id": cfg["host_id"], "purpose": "device-enroll-v1", "ts": int(time.time()), "nonce": secrets.token_hex(16)}, key)
|
||||
response = http.post(URL + "/device/register", json={"host_id": cfg["host_id"], "proof": proof,
|
||||
"public_key": key.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo).decode()})
|
||||
if response.status_code not in {200, 201}:
|
||||
raise RuntimeError("自动注册失败:HTTP " + str(response.status_code) + ";请确认ECS已安装1.067自动注册更新。")
|
||||
receipt = verified(response.json(), load_public(directory / "connector.pub"))
|
||||
if receipt.get("status") != "registered" or receipt["host_id"] != cfg["host_id"]:
|
||||
raise ValueError("注册回执身份不符")
|
||||
public = verify_device(receipt["cert"], (directory / "ca.pem").read_bytes(), cfg["host_id"])
|
||||
if raw_public(public) != raw_public(key.public_key()):
|
||||
raise ValueError("注册证书公钥不符")
|
||||
temp = directory / "device.pem.tmp"
|
||||
temp.write_text(receipt["cert"], encoding="utf-8")
|
||||
os.replace(temp, directory / "device.pem")
|
||||
(directory / "enrollment.json").unlink(missing_ok=True)
|
||||
return {"message": "设备已自动注册,无需管理员审批。请在Work获取绑定码,填写后点击绑定并连接。"}
|
||||
|
||||
|
||||
def managed_processes(directory):
|
||||
"""Only processes with our absolute entry path AND exact device directory."""
|
||||
state = directory / "processes.json"
|
||||
if not state.exists():
|
||||
return []
|
||||
result = []
|
||||
for item in json.loads(state.read_text()).get("processes", []):
|
||||
try:
|
||||
proc = psutil.Process(item["pid"])
|
||||
command = proc.cmdline()
|
||||
if (abs(proc.create_time() - item["created"]) < 0.1 and str(BASE / "entry.py") in command
|
||||
and str(directory) in command):
|
||||
result.append(proc)
|
||||
except psutil.Error:
|
||||
pass
|
||||
return result
|
||||
|
||||
|
||||
def stop(directory):
|
||||
procs = managed_processes(directory)
|
||||
# Supervisor owns and terminates only its own child handles in its finally block.
|
||||
(directory / "stop.flag").touch()
|
||||
_, alive = psutil.wait_procs(procs, timeout=8)
|
||||
for proc in alive:
|
||||
proc.terminate()
|
||||
return {"message": "已停止本安装包启动的连接进程。手工启动的旧桥接请在原窗口按Ctrl+C停止。"}
|
||||
|
||||
|
||||
def start(directory, root):
|
||||
from .process_lock import DeviceProcessLock
|
||||
with DeviceProcessLock(directory / "control"):
|
||||
return _start(directory, root)
|
||||
|
||||
|
||||
def _start(directory, root):
|
||||
cfg = json.loads((directory / "device.json").read_text())
|
||||
if not cfg.get("owner") or not (directory / "device.pem").exists():
|
||||
raise RuntimeError("请先完成设备准入和Work绑定。")
|
||||
if managed_processes(directory):
|
||||
return {"message": "连接进程已运行,请点击状态查看。"}
|
||||
(directory / "stop.flag").unlink(missing_ok=True)
|
||||
log = (directory / "bridge.log").open("a", encoding="utf-8")
|
||||
proc = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "supervise", "--directory", str(directory), "--root", str(root)],
|
||||
stdout=log, stderr=log, creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
log.close()
|
||||
save(directory / "processes.json", {"processes": [{"pid": proc.pid, "created": psutil.Process(proc.pid).create_time()}]})
|
||||
return {"message": "连接进程已启动;约30秒后点击状态,再到Work发送 /主机名 验证。"}
|
||||
|
||||
|
||||
def supervise(directory, root):
|
||||
from .process_lock import DeviceProcessLock
|
||||
lockdir = directory / "supervisor"
|
||||
with DeviceProcessLock(lockdir):
|
||||
children = []
|
||||
def record_children():
|
||||
processes = [psutil.Process(os.getpid())] + [psutil.Process(p.pid) for p in children if p.poll() is None]
|
||||
save(directory / "processes.json", {"processes": [{"pid": p.pid, "created": p.create_time()} for p in processes]})
|
||||
try:
|
||||
# Check local bind availability without an HTTP connection. Windows
|
||||
# filtering can time out connections to a closed port rather than
|
||||
# refuse them; that must not prevent starting our own listener.
|
||||
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as port_probe:
|
||||
try:
|
||||
if os.name == "nt":
|
||||
port_probe.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
|
||||
port_probe.bind(("127.0.0.1", 18643))
|
||||
except OSError:
|
||||
raise RuntimeError("原生API端口18643被占用或不允许绑定,请先检查旧连接。") from None
|
||||
native = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "native", "--directory", str(directory), "--root", str(root)])
|
||||
children.append(native)
|
||||
record_children()
|
||||
for _ in range(90):
|
||||
if (directory / "stop.flag").exists():
|
||||
return
|
||||
if native.poll() is not None:
|
||||
raise RuntimeError("本机原生API启动失败,请检查安装配置。")
|
||||
try:
|
||||
from .hainuo1065 import Hainuo1065Agent
|
||||
async def probe():
|
||||
agent = Hainuo1065Agent(directory / "hainuo-native.json")
|
||||
try:
|
||||
return await agent.probe()
|
||||
finally:
|
||||
await agent.close()
|
||||
asyncio.run(probe())
|
||||
break
|
||||
except Exception:
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise RuntimeError("本机原生API未就绪。")
|
||||
bridge = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "bridge", "--directory", str(directory), "--root", str(root)])
|
||||
children.append(bridge)
|
||||
record_children()
|
||||
while not (directory / "stop.flag").exists():
|
||||
if any(proc.poll() is not None for proc in children):
|
||||
raise RuntimeError("连接子进程已退出,请查看状态后重新启动。")
|
||||
time.sleep(0.5)
|
||||
finally:
|
||||
for proc in reversed(children):
|
||||
if proc.poll() is None:
|
||||
proc.terminate()
|
||||
try:
|
||||
proc.wait(timeout=5)
|
||||
except subprocess.TimeoutExpired:
|
||||
proc.kill()
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("action", choices=["import", "enroll", "bind", "start", "stop", "status", "pair", "supervise", "native", "bridge"])
|
||||
parser.add_argument("--directory", type=Path, required=True)
|
||||
parser.add_argument("--root", type=Path, required=True)
|
||||
args = parser.parse_args()
|
||||
directory, root = args.directory.resolve(), args.root.resolve()
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
try:
|
||||
if args.action == "import":
|
||||
result = import_existing(directory, Path(sys.stdin.readline().strip()))
|
||||
elif args.action == "enroll":
|
||||
result = enrollment(directory)
|
||||
elif args.action == "bind":
|
||||
from .device import bind_device
|
||||
code = sys.stdin.readline().strip()
|
||||
if not code:
|
||||
raise ValueError("请填写Work机器人新生成的绑定码。")
|
||||
enrollment(directory)
|
||||
stop(directory)
|
||||
asyncio.run(bind_device(directory, URL, code, tls_verify=tls(directory)))
|
||||
result = start(directory, root)
|
||||
result["message"] = "Work绑定成功。" + result["message"]
|
||||
elif args.action == "start":
|
||||
result = start(directory, root)
|
||||
elif args.action == "stop":
|
||||
result = stop(directory)
|
||||
elif args.action == "pair":
|
||||
from .device import pair_browser
|
||||
receipt = asyncio.run(pair_browser(directory, URL, tls_verify=tls(directory)))
|
||||
result = {"message": "网页:" + receipt["url"] + "\n一次性配对码(120秒):" + receipt["code"]}
|
||||
elif args.action == "status":
|
||||
cfg = json.loads((directory / "device.json").read_text()) if (directory / "device.json").exists() else {}
|
||||
log = directory / "bridge.log"
|
||||
tail = log.read_bytes()[-6000:].decode("utf-8", errors="replace") if log.exists() else ""
|
||||
result = {"message": "设备:" + cfg.get("host_id", "未申请") + "\nWork身份:" + (cfg.get("owner") or "未绑定")
|
||||
+ "\n连接进程:" + ("运行中(请在Work发送 /主机名 确认当前链路)" if managed_processes(directory) else "未运行") + "\n" + tail[-2500:]}
|
||||
elif args.action == "supervise":
|
||||
return supervise(directory, root)
|
||||
elif args.action == "native":
|
||||
import importlib.util
|
||||
spec = importlib.util.spec_from_file_location("native_companion", BASE / "hainuo_native_api.py")
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
module.enable_profile_tools(root, "hainuo")
|
||||
key = module.prepare_environment(root, "hainuo", 18643, directory / "hainuo-native.json", enable_tools=True)
|
||||
import logging
|
||||
logging.disable(logging.CRITICAL)
|
||||
return asyncio.run(module.serve_native(18643, key, enable_tools=True))
|
||||
else:
|
||||
from .device import run_device
|
||||
return asyncio.run(run_device(directory, "wss://10.77.76.13/device/ws", ssl_context=tls(directory), hainuo_config=directory / "hainuo-native.json"))
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
except Exception as error:
|
||||
# Native exception bodies may include URLs or secrets; emit bounded known messages only.
|
||||
message = str(error) if isinstance(error, (RuntimeError, ValueError)) else type(error).__name__ + ";请检查网络、证书、安装目录。"
|
||||
print(json.dumps({"message": message[:600], "error": True}, ensure_ascii=False))
|
||||
raise SystemExit(1) from None
|
||||
|
||||
|
||||
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,65 @@
|
||||
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
|
||||
enrollment_signer_url: str = ""
|
||||
|
||||
@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,503 @@
|
||||
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)
|
||||
|
||||
from .enrollment import enrollment_router
|
||||
app.include_router(enrollment_router(s, r, store, broker.signer, admin))
|
||||
|
||||
@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:
|
||||
instruction = text if text.startswith("/助手 ") else "/助手 " + text
|
||||
result = (await broker.dispatch(owner, instruction, "msg_" + hashlib.sha256(message_id.encode()).hexdigest()))["result"]
|
||||
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,140 @@
|
||||
"""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):
|
||||
protected = path.with_name(path.name + ".dpapi")
|
||||
if protected.is_file():
|
||||
from .windows_keys import unprotect
|
||||
data = unprotect(protected.read_bytes())
|
||||
else:
|
||||
data = path.read_bytes()
|
||||
return serialization.load_pem_private_key(data, 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,216 @@
|
||||
"""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, trust_env=False, 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, **kwargs):
|
||||
from .process_lock import DeviceProcessLock
|
||||
with DeviceProcessLock(directory):
|
||||
return await _run_device(directory, router_url, **kwargs)
|
||||
|
||||
|
||||
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")
|
||||
print("设备连接成功,已绑定本人海能Work身份。", flush=True)
|
||||
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 as error:
|
||||
if once:
|
||||
raise
|
||||
from websockets.exceptions import ConnectionClosed
|
||||
if isinstance(error, ConnectionClosed) and error.rcvd and error.rcvd.code == 1008:
|
||||
print("设备被中继拒绝:请检查是否有另一桥接进程、设备准入或证书状态。", flush=True)
|
||||
# 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,178 @@
|
||||
"""Device registration with key possession proof; Work binding is separate."""
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
import httpx
|
||||
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from pydantic import BaseModel, Field
|
||||
from .common import no_cache, peer, rate_limit
|
||||
from .crypto import verified, sign, raw_public, verify_device, fingerprint
|
||||
from .web_session import digest
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
|
||||
def validate_enrollment(body):
|
||||
try:
|
||||
key = serialization.load_pem_public_key(body.public_key.encode())
|
||||
if not isinstance(key, Ed25519PublicKey):
|
||||
raise ValueError()
|
||||
proof = verified(body.proof, key)
|
||||
if (proof["host_id"] != body.host_id or proof["purpose"] != "device-enroll-v1"
|
||||
or abs(time.time() - proof["ts"]) > 90 or len(proof["nonce"]) != 32):
|
||||
raise ValueError()
|
||||
return key
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid enrollment proof") from None
|
||||
|
||||
|
||||
async def request_certificate(settings, body):
|
||||
async with httpx.AsyncClient(trust_env=False, timeout=15, follow_redirects=False) as http:
|
||||
response = await http.post(settings.enrollment_signer_url.rstrip("/") + "/issue",
|
||||
headers={"X-Internal-Secret": settings.internal_secret},
|
||||
json=body.model_dump())
|
||||
response.raise_for_status()
|
||||
return response.json()["cert"]
|
||||
|
||||
|
||||
class EnrollmentRequest(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
public_key: str = Field(max_length=1024)
|
||||
proof: dict
|
||||
|
||||
|
||||
class EnrollmentApproval(BaseModel):
|
||||
cert: str = Field(max_length=10000)
|
||||
|
||||
|
||||
def enrollment_router(settings, redis, store, signer, admin):
|
||||
router = APIRouter()
|
||||
|
||||
@router.post("/device/register")
|
||||
async def automatic_registration(body: EnrollmentRequest, request: Request):
|
||||
# No human approval: eligibility follows intranet access plus Work app scope.
|
||||
# Proof/TLS/limits protect identity and resources, and do not add user approval.
|
||||
await rate_limit(redis, "auto-register-ip:" + peer(request), 120)
|
||||
key = validate_enrollment(body)
|
||||
await rate_limit(redis, "auto-register-host:" + body.host_id, 30)
|
||||
existing = store.device(body.host_id)
|
||||
|
||||
def check_existing(device):
|
||||
if device["revoked"]:
|
||||
raise HTTPException(403, "device revoked")
|
||||
try:
|
||||
registered = verify_device(device["cert"], settings.ca_cert.read_bytes(), body.host_id)
|
||||
if raw_public(registered) != raw_public(key):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(409, "existing device identity mismatch or certificate expired") from None
|
||||
return device["cert"]
|
||||
|
||||
if existing:
|
||||
cert = check_existing(existing)
|
||||
else:
|
||||
if not settings.enrollment_signer_url:
|
||||
raise HTTPException(503, "automatic registration is not enabled; update ECS first")
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= settings.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
await rate_limit(redis, "auto-register-total", settings.max_pending, 3600)
|
||||
try:
|
||||
cert = await request_certificate(settings, body)
|
||||
issued = verify_device(cert, settings.ca_cert.read_bytes(), body.host_id)
|
||||
if raw_public(issued) != raw_public(key):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(503, "certificate issuer unavailable or invalid response") from None
|
||||
from .store import INTEGRITY_ERRORS
|
||||
try:
|
||||
store.add_device(body.host_id, cert, fingerprint(cert))
|
||||
except INTEGRITY_ERRORS:
|
||||
# A retry/concurrent request must return the original certificate.
|
||||
cert = check_existing(store.device(body.host_id))
|
||||
store.audit("device", "automatic_registration", body.host_id, "success")
|
||||
await redis.set("hn:device:" + body.host_id, fingerprint(cert))
|
||||
return no_cache(JSONResponse(sign({"status": "registered", "host_id": body.host_id,
|
||||
"cert": cert}, signer), status_code=201 if not existing else 200))
|
||||
|
||||
@router.post("/device/enroll")
|
||||
async def request_enrollment(body: EnrollmentRequest, request: Request):
|
||||
await rate_limit(redis, "enroll-ip:" + peer(request), 10)
|
||||
validate_enrollment(body)
|
||||
await rate_limit(redis, "enroll-host:" + body.host_id, 3, 3600)
|
||||
if store.device(body.host_id):
|
||||
raise HTTPException(409, "device already registered; recover its original certificate")
|
||||
# Global rolling capacity bound; prevents anonymous request-table exhaustion.
|
||||
await rate_limit(redis, "enroll-global", settings.max_pending, 1800)
|
||||
identifier, claim_secret = secrets.token_hex(16), secrets.token_urlsafe(32)
|
||||
record = {"host_id": body.host_id, "public_key": body.public_key,
|
||||
"claim_hash": digest(claim_secret), "created": time.time(), "status": "pending"}
|
||||
await redis.set("hn:enroll:" + identifier, json.dumps(record), ex=1800)
|
||||
return no_cache(JSONResponse(sign({"request_id": identifier, "claim_secret": claim_secret,
|
||||
"host_id": body.host_id, "expires_in": 1800}, signer), status_code=201))
|
||||
|
||||
@router.get("/device/enroll/{identifier}")
|
||||
async def claim(identifier: str, request: Request):
|
||||
await rate_limit(redis, "enroll-poll:" + peer(request), 60)
|
||||
data = await redis.get("hn:enroll:" + identifier)
|
||||
if not data:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(data)
|
||||
import hmac
|
||||
if not hmac.compare_digest(record["claim_hash"], digest(request.headers.get("X-Enrollment-Secret", ""))):
|
||||
raise HTTPException(404, "request unavailable")
|
||||
if record["status"] == "pending":
|
||||
return no_cache(JSONResponse({"status": "pending"}, status_code=202))
|
||||
device = store.device(record["host_id"])
|
||||
if not device or device["revoked"]:
|
||||
raise HTTPException(403, "device unavailable")
|
||||
# Recoverable for its original claimant for the request TTL; public certificate only.
|
||||
return no_cache(JSONResponse(sign({"status": "approved", "host_id": record["host_id"],
|
||||
"request_id": identifier, "cert": device["cert"]}, signer)))
|
||||
|
||||
@router.get("/admin/enrollments/{identifier}")
|
||||
async def inspect(identifier: str, request: Request):
|
||||
admin(request)
|
||||
encoded = await redis.get("hn:enroll:" + identifier)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(encoded)
|
||||
return {k: v for k, v in record.items() if k != "claim_hash"}
|
||||
|
||||
@router.post("/admin/enrollments/{identifier}/approve")
|
||||
async def approve(identifier: str, body: EnrollmentApproval, request: Request):
|
||||
admin(request)
|
||||
encoded = await redis.get("hn:enroll:" + identifier)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(encoded)
|
||||
try:
|
||||
public = verify_device(body.cert, settings.ca_cert.read_bytes(), record["host_id"])
|
||||
requested = serialization.load_pem_public_key(record["public_key"].encode())
|
||||
if raw_public(public) != raw_public(requested):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(400, "certificate does not match enrollment") from None
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= settings.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
fp = fingerprint(body.cert)
|
||||
existing = store.device(record["host_id"])
|
||||
if existing and (existing["revoked"] or existing["fingerprint"] != fp):
|
||||
raise HTTPException(409, "device conflict")
|
||||
if not existing:
|
||||
from .store import INTEGRITY_ERRORS
|
||||
try:
|
||||
store.add_device(record["host_id"], body.cert, fp)
|
||||
except INTEGRITY_ERRORS:
|
||||
raise HTTPException(409, "concurrent device registration") from None
|
||||
await redis.set("hn:device:" + record["host_id"], fp)
|
||||
record["status"] = "approved"
|
||||
remaining = await redis.ttl("hn:enroll:" + identifier)
|
||||
if remaining < 1:
|
||||
raise HTTPException(409, "request expired during approval")
|
||||
await redis.set("hn:enroll:" + identifier, json.dumps(record), ex=remaining)
|
||||
store.audit("admin", "enrollment_approved", record["host_id"], "success")
|
||||
return {"status": "approved", "host_id": record["host_id"]}
|
||||
|
||||
return router
|
||||
@@ -0,0 +1,43 @@
|
||||
"""Internal automatic CA issuer. No published host port, no application credentials."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from cryptography import x509
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from fastapi import FastAPI, Request
|
||||
from .common import BodyLimitMiddleware, require_secret
|
||||
from .crypto import load_private, issue_device, raw_public, verify_device
|
||||
from .enrollment import EnrollmentRequest, validate_enrollment
|
||||
|
||||
|
||||
def create_app(*, ca_key_path=None, ca_cert_path=None, secret=None):
|
||||
key = load_private(Path(ca_key_path or os.environ.get("HN_ISSUER_CA_KEY", "/issuer/ca.key")))
|
||||
ca_bytes = Path(ca_cert_path or os.environ.get("HN_ISSUER_CA_CERT", "/trust/ca.pem")).read_bytes()
|
||||
ca = x509.load_pem_x509_certificate(ca_bytes)
|
||||
if raw_public(key.public_key()) != raw_public(ca.public_key()):
|
||||
raise ValueError("issuer CA key mismatch")
|
||||
token = secret or os.environ.get("HN_INTERNAL_SECRET", "")
|
||||
if len(token) < 32:
|
||||
raise ValueError("issuer requires internal credential")
|
||||
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app.add_middleware(BodyLimitMiddleware, max_body=16384)
|
||||
|
||||
@app.get("/ready")
|
||||
async def ready():
|
||||
return {"status": "ready"}
|
||||
|
||||
@app.post("/issue")
|
||||
async def issue(body: EnrollmentRequest, request: Request):
|
||||
require_secret(request.headers.get("X-Internal-Secret"), token)
|
||||
public = validate_enrollment(body)
|
||||
cert = issue_device(key, ca, body.host_id, public).public_bytes(serialization.Encoding.PEM).decode()
|
||||
verify_device(cert, ca_bytes, body.host_id)
|
||||
return {"cert": cert}
|
||||
|
||||
return app
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import uvicorn
|
||||
uvicorn.run("relay.enrollment_signer:create_app", factory=True, host="0.0.0.0", port=8000,
|
||||
workers=1, access_log=False, proxy_headers=False, log_level="warning")
|
||||
@@ -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,46 @@
|
||||
"""Per-device advisory process lock: same-user GUI and CLI cannot race."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class DeviceAlreadyRunning(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class DeviceProcessLock:
|
||||
def __init__(self, directory):
|
||||
self.path = Path(directory) / "bridge.lock"
|
||||
self.file = None
|
||||
|
||||
def __enter__(self):
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.file = self.path.open("a+b")
|
||||
self.file.seek(0, 2)
|
||||
if self.file.tell() == 0:
|
||||
self.file.write(b"0")
|
||||
self.file.flush()
|
||||
self.file.seek(0)
|
||||
try:
|
||||
if os.name == "nt":
|
||||
import msvcrt
|
||||
msvcrt.locking(self.file.fileno(), msvcrt.LK_NBLCK, 1)
|
||||
else:
|
||||
import fcntl
|
||||
fcntl.flock(self.file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
except OSError:
|
||||
self.file.close()
|
||||
self.file = None
|
||||
raise DeviceAlreadyRunning("该设备已有桥接进程运行,请勿重复启动。") from None
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
if self.file:
|
||||
self.file.seek(0)
|
||||
if os.name == "nt":
|
||||
import msvcrt
|
||||
msvcrt.locking(self.file.fileno(), msvcrt.LK_UNLCK, 1)
|
||||
else:
|
||||
import fcntl
|
||||
fcntl.flock(self.file.fileno(), fcntl.LOCK_UN)
|
||||
self.file.close()
|
||||
self.file = None
|
||||
@@ -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,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
|
||||
@@ -0,0 +1,40 @@
|
||||
"""Current-user Windows DPAPI for device keys; never uses machine-wide scope."""
|
||||
import ctypes
|
||||
import os
|
||||
from ctypes import wintypes
|
||||
|
||||
|
||||
class Blob(ctypes.Structure):
|
||||
_fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_ubyte))]
|
||||
|
||||
|
||||
def transform(data, decrypt=False):
|
||||
if os.name != "nt":
|
||||
raise RuntimeError("DPAPI is supported only on Windows")
|
||||
buffer = (ctypes.c_ubyte * len(data)).from_buffer_copy(data)
|
||||
source = Blob(len(data), buffer)
|
||||
target = Blob()
|
||||
crypt = ctypes.WinDLL("crypt32", use_last_error=True)
|
||||
kernel = ctypes.WinDLL("kernel32", use_last_error=True)
|
||||
if decrypt:
|
||||
fn = crypt.CryptUnprotectData
|
||||
args = [ctypes.byref(source), None, None, None, None, 1, ctypes.byref(target)]
|
||||
else:
|
||||
fn = crypt.CryptProtectData
|
||||
args = [ctypes.byref(source), "Hainuo device identity", None, None, None, 1, ctypes.byref(target)]
|
||||
fn.restype = wintypes.BOOL
|
||||
if not fn(*args):
|
||||
raise ctypes.WinError(ctypes.get_last_error())
|
||||
try:
|
||||
return ctypes.string_at(target.pbData, target.cbData)
|
||||
finally:
|
||||
kernel.LocalFree.argtypes = [ctypes.c_void_p]
|
||||
kernel.LocalFree(target.pbData)
|
||||
|
||||
|
||||
def protect(data):
|
||||
return transform(data)
|
||||
|
||||
|
||||
def unprotect(data):
|
||||
return transform(data, decrypt=True)
|
||||
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
root=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
|
||||
cd "$root"
|
||||
test -f .env && test -d wheelhouse && test -f Dockerfile.offline
|
||||
stamp=$(date +%Y%m%d-%H%M%S)
|
||||
# Enable automatic issuance using the current test CA, never generate a new CA.
|
||||
# Only the internal issuer container receives this key; no host port is published.
|
||||
if [[ ! -f runtime/issuer/ca.key ]]; then
|
||||
test -f operator/ca.key || { echo 'Existing CA key missing: provide the original CA to the internal issuer first.' >&2; exit 1; }
|
||||
install -d -m 700 -o 10001 -g 10001 runtime/issuer
|
||||
install -m 400 -o 10001 -g 10001 operator/ca.key runtime/issuer/ca.key
|
||||
fi
|
||||
docker image tag hainuo-relay:0.1.0 "hainuo-relay:before-work1067-$stamp"
|
||||
docker build --network none --pull=false -f Dockerfile.offline -t hainuo-relay:0.1.0 .
|
||||
args=(-f compose.yaml)
|
||||
for override in compose.offline.yaml compose.edge-fix.yaml compose.h5.yaml compose.work.yaml compose.feishu.yaml; do
|
||||
if [[ -f "$override" ]]; then args+=(-f "$override"); fi
|
||||
done
|
||||
args+=(-f compose.autoreg.yaml)
|
||||
# Bring up signer and verify it before changing the serving connector.
|
||||
docker compose "${args[@]}" up -d --no-build --pull never --no-deps --force-recreate enrollment-signer
|
||||
docker compose "${args[@]}" exec -T enrollment-signer python -c 'import time,urllib.request
|
||||
for attempt in range(30):
|
||||
try:
|
||||
urllib.request.urlopen("http://127.0.0.1:8000/ready", timeout=2)
|
||||
print("Automatic certificate issuer ready")
|
||||
break
|
||||
except Exception:
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise SystemExit("Issuer not ready; connector unchanged")'
|
||||
docker compose "${args[@]}" up -d --no-build --pull never --no-deps --force-recreate connector router
|
||||
if [[ -n "$(docker compose -f compose.yaml ps -q longconn)" ]]; then
|
||||
docker compose "${args[@]}" --profile longconn up -d --no-build --pull never --no-deps --force-recreate longconn
|
||||
fi
|
||||
docker compose "${args[@]}" ps
|
||||
echo "Previous image: hainuo-relay:before-work1067-$stamp"
|
||||
echo 'Automatic registration enabled. New PCs only need a Work binding code; no per-PC approval command.'
|
||||
echo 'Keep -f compose.autoreg.yaml in future compose up commands.'
|
||||
@@ -0,0 +1,10 @@
|
||||
FROM python:3.12-slim-bookworm
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1
|
||||
WORKDIR /app
|
||||
COPY wheelhouse /wheels
|
||||
COPY requirements.lock pyproject.toml ./
|
||||
COPY relay ./relay
|
||||
RUN pip install --no-index --find-links=/wheels --no-cache-dir -r requirements.lock && rm -rf /wheels
|
||||
RUN chmod -R a+rX /app
|
||||
USER 10001:10001
|
||||
ENTRYPOINT ["python", "-m", "relay.cli"]
|
||||
@@ -0,0 +1,39 @@
|
||||
services:
|
||||
connector:
|
||||
environment:
|
||||
HN_ENROLLMENT_SIGNER_URL: <REDACTED_LITERAL>
|
||||
depends_on:
|
||||
enrollment-signer:
|
||||
condition: service_healthy
|
||||
enrollment-signer:
|
||||
image: hainuo-relay:0.1.0
|
||||
entrypoint:
|
||||
- python
|
||||
- -m
|
||||
- relay.enrollment_signer
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
HN_INTERNAL_SECRET: ${HN_INTERNAL_SECRET}
|
||||
volumes:
|
||||
- ./runtime/issuer:/issuer:ro
|
||||
- ./runtime/trust:/trust:ro
|
||||
networks:
|
||||
- backend
|
||||
read_only: true
|
||||
tmpfs:
|
||||
- /tmp:size=16m,noexec,nosuid
|
||||
cap_drop:
|
||||
- ALL
|
||||
security_opt:
|
||||
- no-new-privileges:true
|
||||
mem_limit: 128m
|
||||
healthcheck:
|
||||
test:
|
||||
- CMD
|
||||
- python
|
||||
- -c
|
||||
- import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/ready',
|
||||
timeout=3)
|
||||
interval: 10s
|
||||
timeout: 5s
|
||||
retries: 5
|
||||
@@ -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,279 @@
|
||||
"""Per-user Windows connection companion. No platform/application secrets."""
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import ssl
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
import psutil
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
|
||||
from .crypto import load_private, load_public, pem_private, raw_public, sign, verified, verify_device
|
||||
from .windows_keys import protect
|
||||
|
||||
BASE = Path(__file__).resolve().parent.parent
|
||||
URL = "https://10.77.76.13"
|
||||
|
||||
|
||||
def save(path, value):
|
||||
temp = path.with_suffix(path.suffix + ".tmp")
|
||||
temp.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
os.replace(temp, path)
|
||||
|
||||
|
||||
def secure_directory(directory):
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
# SID avoids localized account names. Fail closed if ACL protection fails.
|
||||
result = subprocess.run(["whoami", "/user", "/fo", "csv", "/nh"], capture_output=True, text=True, check=True)
|
||||
import csv
|
||||
sid = list(csv.reader([result.stdout.strip()]))[0][1]
|
||||
subprocess.run(["icacls", str(directory), "/inheritance:r", "/grant:r", f"*{sid}:(OI)(CI)F", "*S-1-5-18:(OI)(CI)F"],
|
||||
capture_output=True, check=True, creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
|
||||
|
||||
def prepare(directory):
|
||||
secure_directory(directory)
|
||||
for name in ("server.pem", "ca.pem", "connector.pub"):
|
||||
target = directory / name
|
||||
if not target.exists():
|
||||
target.write_bytes((BASE / "trust" / name).read_bytes())
|
||||
if not (directory / "device.json").exists():
|
||||
if (directory / "device.key.dpapi").exists() or (directory / "device.key").exists():
|
||||
raise RuntimeError("发现不完整的设备身份,请保留目录并联系管理员恢复。")
|
||||
private = Ed25519PrivateKey.generate()
|
||||
(directory / "device.key.dpapi").write_bytes(protect(pem_private(private)))
|
||||
save(directory / "device.json", {"host_id": uuid.uuid4().hex, "owner": None})
|
||||
|
||||
|
||||
def tls(directory):
|
||||
return ssl.create_default_context(cafile=str(directory / "server.pem"))
|
||||
|
||||
|
||||
def import_existing(directory, source):
|
||||
"""Explicit migration; only public trust and this PC's identity, never app keys."""
|
||||
if source.resolve() == directory.resolve():
|
||||
raise ValueError("请选择旧设备目录。")
|
||||
if any((directory / name).exists() for name in ("device.json", "device.key.dpapi", "device.key")):
|
||||
raise RuntimeError("本目录已有设备身份。请使用已有身份继续,不能用导入覆盖。")
|
||||
config = json.loads((source / "device.json").read_text(encoding="utf-8-sig"))
|
||||
for name in ("server.pem", "ca.pem", "connector.pub"):
|
||||
if (source / name).read_bytes().strip() != (BASE / "trust" / name).read_bytes().strip():
|
||||
raise ValueError("旧设备的服务信任与本安装包不符,请联系管理员。")
|
||||
cert = (source / "device.pem").read_text(encoding="utf-8")
|
||||
public = verify_device(cert, (source / "ca.pem").read_bytes(), config["host_id"])
|
||||
private = load_private(source / "device.key")
|
||||
if raw_public(public) != raw_public(private.public_key()):
|
||||
raise ValueError("设备证书与本机私钥不匹配。")
|
||||
secure_directory(directory)
|
||||
for name in ("device.pem", "server.pem", "ca.pem", "connector.pub"):
|
||||
(directory / name).write_bytes((source / name).read_bytes())
|
||||
(directory / "device.key.dpapi").write_bytes(protect(pem_private(private)))
|
||||
save(directory / "device.json", config)
|
||||
# Preserve local replay journal using SQLite's consistent backup API.
|
||||
if (source / "journal.sqlite").is_file():
|
||||
import sqlite3
|
||||
with sqlite3.connect(source / "journal.sqlite") as original, sqlite3.connect(directory / "journal.sqlite") as target:
|
||||
original.backup(target)
|
||||
return {"message": "旧设备导入成功,Work绑定已保留。请先停止旧PowerShell桥接窗口,再点击启动连接。"}
|
||||
|
||||
|
||||
def enrollment(directory):
|
||||
prepare(directory)
|
||||
cfg = json.loads((directory / "device.json").read_text())
|
||||
if (directory / "device.pem").exists():
|
||||
verify_device((directory / "device.pem").read_text(), (directory / "ca.pem").read_bytes(), cfg["host_id"])
|
||||
return {"message": "设备已注册,可在Work获取绑定码后绑定。已有绑定可直接启动连接。"}
|
||||
with httpx.Client(verify=tls(directory), trust_env=False, timeout=15) as http:
|
||||
key = load_private(directory / "device.key")
|
||||
proof = sign({"host_id": cfg["host_id"], "purpose": "device-enroll-v1", "ts": int(time.time()), "nonce": secrets.token_hex(16)}, key)
|
||||
response = http.post(URL + "/device/register", json={"host_id": cfg["host_id"], "proof": proof,
|
||||
"public_key": key.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo).decode()})
|
||||
if response.status_code not in {200, 201}:
|
||||
raise RuntimeError("自动注册失败:HTTP " + str(response.status_code) + ";请确认ECS已安装1.067自动注册更新。")
|
||||
receipt = verified(response.json(), load_public(directory / "connector.pub"))
|
||||
if receipt.get("status") != "registered" or receipt["host_id"] != cfg["host_id"]:
|
||||
raise ValueError("注册回执身份不符")
|
||||
public = verify_device(receipt["cert"], (directory / "ca.pem").read_bytes(), cfg["host_id"])
|
||||
if raw_public(public) != raw_public(key.public_key()):
|
||||
raise ValueError("注册证书公钥不符")
|
||||
temp = directory / "device.pem.tmp"
|
||||
temp.write_text(receipt["cert"], encoding="utf-8")
|
||||
os.replace(temp, directory / "device.pem")
|
||||
(directory / "enrollment.json").unlink(missing_ok=True)
|
||||
return {"message": "设备已自动注册,无需管理员审批。请在Work获取绑定码,填写后点击绑定并连接。"}
|
||||
|
||||
|
||||
def managed_processes(directory):
|
||||
"""Only processes with our absolute entry path AND exact device directory."""
|
||||
state = directory / "processes.json"
|
||||
if not state.exists():
|
||||
return []
|
||||
result = []
|
||||
for item in json.loads(state.read_text()).get("processes", []):
|
||||
try:
|
||||
proc = psutil.Process(item["pid"])
|
||||
command = proc.cmdline()
|
||||
if (abs(proc.create_time() - item["created"]) < 0.1 and str(BASE / "entry.py") in command
|
||||
and str(directory) in command):
|
||||
result.append(proc)
|
||||
except psutil.Error:
|
||||
pass
|
||||
return result
|
||||
|
||||
|
||||
def stop(directory):
|
||||
procs = managed_processes(directory)
|
||||
# Supervisor owns and terminates only its own child handles in its finally block.
|
||||
(directory / "stop.flag").touch()
|
||||
_, alive = psutil.wait_procs(procs, timeout=8)
|
||||
for proc in alive:
|
||||
proc.terminate()
|
||||
return {"message": "已停止本安装包启动的连接进程。手工启动的旧桥接请在原窗口按Ctrl+C停止。"}
|
||||
|
||||
|
||||
def start(directory, root):
|
||||
from .process_lock import DeviceProcessLock
|
||||
with DeviceProcessLock(directory / "control"):
|
||||
return _start(directory, root)
|
||||
|
||||
|
||||
def _start(directory, root):
|
||||
cfg = json.loads((directory / "device.json").read_text())
|
||||
if not cfg.get("owner") or not (directory / "device.pem").exists():
|
||||
raise RuntimeError("请先完成设备准入和Work绑定。")
|
||||
if managed_processes(directory):
|
||||
return {"message": "连接进程已运行,请点击状态查看。"}
|
||||
(directory / "stop.flag").unlink(missing_ok=True)
|
||||
log = (directory / "bridge.log").open("a", encoding="utf-8")
|
||||
proc = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "supervise", "--directory", str(directory), "--root", str(root)],
|
||||
stdout=log, stderr=log, creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
log.close()
|
||||
save(directory / "processes.json", {"processes": [{"pid": proc.pid, "created": psutil.Process(proc.pid).create_time()}]})
|
||||
return {"message": "连接进程已启动;约30秒后点击状态,再到Work发送 /主机名 验证。"}
|
||||
|
||||
|
||||
def supervise(directory, root):
|
||||
from .process_lock import DeviceProcessLock
|
||||
lockdir = directory / "supervisor"
|
||||
with DeviceProcessLock(lockdir):
|
||||
children = []
|
||||
def record_children():
|
||||
processes = [psutil.Process(os.getpid())] + [psutil.Process(p.pid) for p in children if p.poll() is None]
|
||||
save(directory / "processes.json", {"processes": [{"pid": p.pid, "created": p.create_time()} for p in processes]})
|
||||
try:
|
||||
with httpx.Client(trust_env=False, timeout=1) as client:
|
||||
try:
|
||||
client.get("http://127.0.0.1:18643/health")
|
||||
except httpx.ConnectError:
|
||||
pass
|
||||
else:
|
||||
raise RuntimeError("原生API端口18643已被占用,请先停止旧连接。")
|
||||
native = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "native", "--directory", str(directory), "--root", str(root)])
|
||||
children.append(native)
|
||||
record_children()
|
||||
for _ in range(90):
|
||||
if (directory / "stop.flag").exists():
|
||||
return
|
||||
if native.poll() is not None:
|
||||
raise RuntimeError("本机原生API启动失败,请检查安装配置。")
|
||||
try:
|
||||
from .hainuo1065 import Hainuo1065Agent
|
||||
async def probe():
|
||||
agent = Hainuo1065Agent(directory / "hainuo-native.json")
|
||||
try:
|
||||
return await agent.probe()
|
||||
finally:
|
||||
await agent.close()
|
||||
asyncio.run(probe())
|
||||
break
|
||||
except Exception:
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise RuntimeError("本机原生API未就绪。")
|
||||
bridge = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "bridge", "--directory", str(directory), "--root", str(root)])
|
||||
children.append(bridge)
|
||||
record_children()
|
||||
while not (directory / "stop.flag").exists():
|
||||
if any(proc.poll() is not None for proc in children):
|
||||
raise RuntimeError("连接子进程已退出,请查看状态后重新启动。")
|
||||
time.sleep(0.5)
|
||||
finally:
|
||||
for proc in reversed(children):
|
||||
if proc.poll() is None:
|
||||
proc.terminate()
|
||||
try:
|
||||
proc.wait(timeout=5)
|
||||
except subprocess.TimeoutExpired:
|
||||
proc.kill()
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("action", choices=["import", "enroll", "bind", "start", "stop", "status", "pair", "supervise", "native", "bridge"])
|
||||
parser.add_argument("--directory", type=Path, required=True)
|
||||
parser.add_argument("--root", type=Path, required=True)
|
||||
args = parser.parse_args()
|
||||
directory, root = args.directory.resolve(), args.root.resolve()
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
try:
|
||||
if args.action == "import":
|
||||
result = import_existing(directory, Path(sys.stdin.readline().strip()))
|
||||
elif args.action == "enroll":
|
||||
result = enrollment(directory)
|
||||
elif args.action == "bind":
|
||||
from .device import bind_device
|
||||
code = sys.stdin.readline().strip()
|
||||
if not code:
|
||||
raise ValueError("请填写Work机器人新生成的绑定码。")
|
||||
enrollment(directory)
|
||||
stop(directory)
|
||||
asyncio.run(bind_device(directory, URL, code, tls_verify=tls(directory)))
|
||||
result = start(directory, root)
|
||||
result["message"] = "Work绑定成功。" + result["message"]
|
||||
elif args.action == "start":
|
||||
result = start(directory, root)
|
||||
elif args.action == "stop":
|
||||
result = stop(directory)
|
||||
elif args.action == "pair":
|
||||
from .device import pair_browser
|
||||
receipt = asyncio.run(pair_browser(directory, URL, tls_verify=tls(directory)))
|
||||
result = {"message": "网页:" + receipt["url"] + "\n一次性配对码(120秒):" + receipt["code"]}
|
||||
elif args.action == "status":
|
||||
cfg = json.loads((directory / "device.json").read_text()) if (directory / "device.json").exists() else {}
|
||||
log = directory / "bridge.log"
|
||||
tail = log.read_bytes()[-6000:].decode("utf-8", errors="replace") if log.exists() else ""
|
||||
result = {"message": "设备:" + cfg.get("host_id", "未申请") + "\nWork身份:" + (cfg.get("owner") or "未绑定")
|
||||
+ "\n连接进程:" + ("运行中(请在Work发送 /主机名 确认当前链路)" if managed_processes(directory) else "未运行") + "\n" + tail[-2500:]}
|
||||
elif args.action == "supervise":
|
||||
return supervise(directory, root)
|
||||
elif args.action == "native":
|
||||
import importlib.util
|
||||
spec = importlib.util.spec_from_file_location("native_companion", BASE / "hainuo_native_api.py")
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
key = module.prepare_environment(root, "hainuo", 18643, directory / "hainuo-native.json")
|
||||
import logging
|
||||
logging.disable(logging.CRITICAL)
|
||||
return asyncio.run(module.serve_native(18643, key))
|
||||
else:
|
||||
from .device import run_device
|
||||
return asyncio.run(run_device(directory, "wss://10.77.76.13/device/ws", ssl_context=tls(directory), hainuo_config=directory / "hainuo-native.json"))
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
except Exception as error:
|
||||
# Native exception bodies may include URLs or secrets; emit bounded known messages only.
|
||||
message = str(error) if isinstance(error, (RuntimeError, ValueError)) else type(error).__name__ + ";请检查网络、证书、安装目录。"
|
||||
print(json.dumps({"message": message[:600], "error": True}, ensure_ascii=False))
|
||||
raise SystemExit(1) from None
|
||||
|
||||
|
||||
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,65 @@
|
||||
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
|
||||
enrollment_signer_url: str = ""
|
||||
|
||||
@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,502 @@
|
||||
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)
|
||||
|
||||
from .enrollment import enrollment_router
|
||||
app.include_router(enrollment_router(s, r, store, broker.signer, admin))
|
||||
|
||||
@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,140 @@
|
||||
"""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):
|
||||
protected = path.with_name(path.name + ".dpapi")
|
||||
if protected.is_file():
|
||||
from .windows_keys import unprotect
|
||||
data = unprotect(protected.read_bytes())
|
||||
else:
|
||||
data = path.read_bytes()
|
||||
return serialization.load_pem_private_key(data, 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,216 @@
|
||||
"""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, trust_env=False, 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, **kwargs):
|
||||
from .process_lock import DeviceProcessLock
|
||||
with DeviceProcessLock(directory):
|
||||
return await _run_device(directory, router_url, **kwargs)
|
||||
|
||||
|
||||
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")
|
||||
print("设备连接成功,已绑定本人海能Work身份。", flush=True)
|
||||
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 as error:
|
||||
if once:
|
||||
raise
|
||||
from websockets.exceptions import ConnectionClosed
|
||||
if isinstance(error, ConnectionClosed) and error.rcvd and error.rcvd.code == 1008:
|
||||
print("设备被中继拒绝:请检查是否有另一桥接进程、设备准入或证书状态。", flush=True)
|
||||
# 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,178 @@
|
||||
"""Device registration with key possession proof; Work binding is separate."""
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
import httpx
|
||||
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from pydantic import BaseModel, Field
|
||||
from .common import no_cache, peer, rate_limit
|
||||
from .crypto import verified, sign, raw_public, verify_device, fingerprint
|
||||
from .web_session import digest
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
|
||||
def validate_enrollment(body):
|
||||
try:
|
||||
key = serialization.load_pem_public_key(body.public_key.encode())
|
||||
if not isinstance(key, Ed25519PublicKey):
|
||||
raise ValueError()
|
||||
proof = verified(body.proof, key)
|
||||
if (proof["host_id"] != body.host_id or proof["purpose"] != "device-enroll-v1"
|
||||
or abs(time.time() - proof["ts"]) > 90 or len(proof["nonce"]) != 32):
|
||||
raise ValueError()
|
||||
return key
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid enrollment proof") from None
|
||||
|
||||
|
||||
async def request_certificate(settings, body):
|
||||
async with httpx.AsyncClient(trust_env=False, timeout=15, follow_redirects=False) as http:
|
||||
response = await http.post(settings.enrollment_signer_url.rstrip("/") + "/issue",
|
||||
headers={"X-Internal-Secret": settings.internal_secret},
|
||||
json=body.model_dump())
|
||||
response.raise_for_status()
|
||||
return response.json()["cert"]
|
||||
|
||||
|
||||
class EnrollmentRequest(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
public_key: str = Field(max_length=1024)
|
||||
proof: dict
|
||||
|
||||
|
||||
class EnrollmentApproval(BaseModel):
|
||||
cert: str = Field(max_length=10000)
|
||||
|
||||
|
||||
def enrollment_router(settings, redis, store, signer, admin):
|
||||
router = APIRouter()
|
||||
|
||||
@router.post("/device/register")
|
||||
async def automatic_registration(body: EnrollmentRequest, request: Request):
|
||||
# No human approval: eligibility follows intranet access plus Work app scope.
|
||||
# Proof/TLS/limits protect identity and resources, and do not add user approval.
|
||||
await rate_limit(redis, "auto-register-ip:" + peer(request), 120)
|
||||
key = validate_enrollment(body)
|
||||
await rate_limit(redis, "auto-register-host:" + body.host_id, 30)
|
||||
existing = store.device(body.host_id)
|
||||
|
||||
def check_existing(device):
|
||||
if device["revoked"]:
|
||||
raise HTTPException(403, "device revoked")
|
||||
try:
|
||||
registered = verify_device(device["cert"], settings.ca_cert.read_bytes(), body.host_id)
|
||||
if raw_public(registered) != raw_public(key):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(409, "existing device identity mismatch or certificate expired") from None
|
||||
return device["cert"]
|
||||
|
||||
if existing:
|
||||
cert = check_existing(existing)
|
||||
else:
|
||||
if not settings.enrollment_signer_url:
|
||||
raise HTTPException(503, "automatic registration is not enabled; update ECS first")
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= settings.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
await rate_limit(redis, "auto-register-total", settings.max_pending, 3600)
|
||||
try:
|
||||
cert = await request_certificate(settings, body)
|
||||
issued = verify_device(cert, settings.ca_cert.read_bytes(), body.host_id)
|
||||
if raw_public(issued) != raw_public(key):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(503, "certificate issuer unavailable or invalid response") from None
|
||||
from .store import INTEGRITY_ERRORS
|
||||
try:
|
||||
store.add_device(body.host_id, cert, fingerprint(cert))
|
||||
except INTEGRITY_ERRORS:
|
||||
# A retry/concurrent request must return the original certificate.
|
||||
cert = check_existing(store.device(body.host_id))
|
||||
store.audit("device", "automatic_registration", body.host_id, "success")
|
||||
await redis.set("hn:device:" + body.host_id, fingerprint(cert))
|
||||
return no_cache(JSONResponse(sign({"status": "registered", "host_id": body.host_id,
|
||||
"cert": cert}, signer), status_code=201 if not existing else 200))
|
||||
|
||||
@router.post("/device/enroll")
|
||||
async def request_enrollment(body: EnrollmentRequest, request: Request):
|
||||
await rate_limit(redis, "enroll-ip:" + peer(request), 10)
|
||||
validate_enrollment(body)
|
||||
await rate_limit(redis, "enroll-host:" + body.host_id, 3, 3600)
|
||||
if store.device(body.host_id):
|
||||
raise HTTPException(409, "device already registered; recover its original certificate")
|
||||
# Global rolling capacity bound; prevents anonymous request-table exhaustion.
|
||||
await rate_limit(redis, "enroll-global", settings.max_pending, 1800)
|
||||
identifier, claim_secret = secrets.token_hex(16), secrets.token_urlsafe(32)
|
||||
record = {"host_id": body.host_id, "public_key": body.public_key,
|
||||
"claim_hash": digest(claim_secret), "created": time.time(), "status": "pending"}
|
||||
await redis.set("hn:enroll:" + identifier, json.dumps(record), ex=1800)
|
||||
return no_cache(JSONResponse(sign({"request_id": identifier, "claim_secret": claim_secret,
|
||||
"host_id": body.host_id, "expires_in": 1800}, signer), status_code=201))
|
||||
|
||||
@router.get("/device/enroll/{identifier}")
|
||||
async def claim(identifier: str, request: Request):
|
||||
await rate_limit(redis, "enroll-poll:" + peer(request), 60)
|
||||
data = await redis.get("hn:enroll:" + identifier)
|
||||
if not data:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(data)
|
||||
import hmac
|
||||
if not hmac.compare_digest(record["claim_hash"], digest(request.headers.get("X-Enrollment-Secret", ""))):
|
||||
raise HTTPException(404, "request unavailable")
|
||||
if record["status"] == "pending":
|
||||
return no_cache(JSONResponse({"status": "pending"}, status_code=202))
|
||||
device = store.device(record["host_id"])
|
||||
if not device or device["revoked"]:
|
||||
raise HTTPException(403, "device unavailable")
|
||||
# Recoverable for its original claimant for the request TTL; public certificate only.
|
||||
return no_cache(JSONResponse(sign({"status": "approved", "host_id": record["host_id"],
|
||||
"request_id": identifier, "cert": device["cert"]}, signer)))
|
||||
|
||||
@router.get("/admin/enrollments/{identifier}")
|
||||
async def inspect(identifier: str, request: Request):
|
||||
admin(request)
|
||||
encoded = await redis.get("hn:enroll:" + identifier)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(encoded)
|
||||
return {k: v for k, v in record.items() if k != "claim_hash"}
|
||||
|
||||
@router.post("/admin/enrollments/{identifier}/approve")
|
||||
async def approve(identifier: str, body: EnrollmentApproval, request: Request):
|
||||
admin(request)
|
||||
encoded = await redis.get("hn:enroll:" + identifier)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(encoded)
|
||||
try:
|
||||
public = verify_device(body.cert, settings.ca_cert.read_bytes(), record["host_id"])
|
||||
requested = serialization.load_pem_public_key(record["public_key"].encode())
|
||||
if raw_public(public) != raw_public(requested):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(400, "certificate does not match enrollment") from None
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= settings.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
fp = fingerprint(body.cert)
|
||||
existing = store.device(record["host_id"])
|
||||
if existing and (existing["revoked"] or existing["fingerprint"] != fp):
|
||||
raise HTTPException(409, "device conflict")
|
||||
if not existing:
|
||||
from .store import INTEGRITY_ERRORS
|
||||
try:
|
||||
store.add_device(record["host_id"], body.cert, fp)
|
||||
except INTEGRITY_ERRORS:
|
||||
raise HTTPException(409, "concurrent device registration") from None
|
||||
await redis.set("hn:device:" + record["host_id"], fp)
|
||||
record["status"] = "approved"
|
||||
remaining = await redis.ttl("hn:enroll:" + identifier)
|
||||
if remaining < 1:
|
||||
raise HTTPException(409, "request expired during approval")
|
||||
await redis.set("hn:enroll:" + identifier, json.dumps(record), ex=remaining)
|
||||
store.audit("admin", "enrollment_approved", record["host_id"], "success")
|
||||
return {"status": "approved", "host_id": record["host_id"]}
|
||||
|
||||
return router
|
||||
@@ -0,0 +1,43 @@
|
||||
"""Internal automatic CA issuer. No published host port, no application credentials."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from cryptography import x509
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from fastapi import FastAPI, Request
|
||||
from .common import BodyLimitMiddleware, require_secret
|
||||
from .crypto import load_private, issue_device, raw_public, verify_device
|
||||
from .enrollment import EnrollmentRequest, validate_enrollment
|
||||
|
||||
|
||||
def create_app(*, ca_key_path=None, ca_cert_path=None, secret=None):
|
||||
key = load_private(Path(ca_key_path or os.environ.get("HN_ISSUER_CA_KEY", "/issuer/ca.key")))
|
||||
ca_bytes = Path(ca_cert_path or os.environ.get("HN_ISSUER_CA_CERT", "/trust/ca.pem")).read_bytes()
|
||||
ca = x509.load_pem_x509_certificate(ca_bytes)
|
||||
if raw_public(key.public_key()) != raw_public(ca.public_key()):
|
||||
raise ValueError("issuer CA key mismatch")
|
||||
token = secret or os.environ.get("HN_INTERNAL_SECRET", "")
|
||||
if len(token) < 32:
|
||||
raise ValueError("issuer requires internal credential")
|
||||
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app.add_middleware(BodyLimitMiddleware, max_body=16384)
|
||||
|
||||
@app.get("/ready")
|
||||
async def ready():
|
||||
return {"status": "ready"}
|
||||
|
||||
@app.post("/issue")
|
||||
async def issue(body: EnrollmentRequest, request: Request):
|
||||
require_secret(request.headers.get("X-Internal-Secret"), token)
|
||||
public = validate_enrollment(body)
|
||||
cert = issue_device(key, ca, body.host_id, public).public_bytes(serialization.Encoding.PEM).decode()
|
||||
verify_device(cert, ca_bytes, body.host_id)
|
||||
return {"cert": cert}
|
||||
|
||||
return app
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import uvicorn
|
||||
uvicorn.run("relay.enrollment_signer:create_app", factory=True, host="0.0.0.0", port=8000,
|
||||
workers=1, access_log=False, proxy_headers=False, log_level="warning")
|
||||
@@ -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,46 @@
|
||||
"""Per-device advisory process lock: same-user GUI and CLI cannot race."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class DeviceAlreadyRunning(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class DeviceProcessLock:
|
||||
def __init__(self, directory):
|
||||
self.path = Path(directory) / "bridge.lock"
|
||||
self.file = None
|
||||
|
||||
def __enter__(self):
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.file = self.path.open("a+b")
|
||||
self.file.seek(0, 2)
|
||||
if self.file.tell() == 0:
|
||||
self.file.write(b"0")
|
||||
self.file.flush()
|
||||
self.file.seek(0)
|
||||
try:
|
||||
if os.name == "nt":
|
||||
import msvcrt
|
||||
msvcrt.locking(self.file.fileno(), msvcrt.LK_NBLCK, 1)
|
||||
else:
|
||||
import fcntl
|
||||
fcntl.flock(self.file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
except OSError:
|
||||
self.file.close()
|
||||
self.file = None
|
||||
raise DeviceAlreadyRunning("该设备已有桥接进程运行,请勿重复启动。") from None
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
if self.file:
|
||||
self.file.seek(0)
|
||||
if os.name == "nt":
|
||||
import msvcrt
|
||||
msvcrt.locking(self.file.fileno(), msvcrt.LK_UNLCK, 1)
|
||||
else:
|
||||
import fcntl
|
||||
fcntl.flock(self.file.fileno(), fcntl.LOCK_UN)
|
||||
self.file.close()
|
||||
self.file = None
|
||||
@@ -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,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
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user