285 lines
14 KiB
Python
285 lines
14 KiB
Python
"""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()
|