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

This commit is contained in:
ex_tianzy
2026-10-27 17:26:58 +08:00
commit 011a7797ee
319 changed files with 34265 additions and 0 deletions
@@ -0,0 +1,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."""
+216
View File
@@ -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."""
+216
View File
@@ -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."""
+216
View File
@@ -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