325 lines
13 KiB
Python
325 lines
13 KiB
Python
"""Web-only atomic storage, portable encrypted credentials and role sessions.
|
|
|
|
Nothing here reads the desktop workspace or its DPAPI records. The key and
|
|
encrypted records must be backed up together. Losing a key is an error, never an
|
|
excuse to replace it and silently discard remembered sessions.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import asdict
|
|
from datetime import datetime, timezone
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import shutil
|
|
import threading
|
|
import uuid
|
|
|
|
from cryptography.fernet import Fernet, InvalidToken
|
|
|
|
from ranch_assistant.api import Session
|
|
|
|
|
|
def _identifier(value, length=32):
|
|
if not isinstance(value, str) or not re.fullmatch(r"[a-f0-9]{%d}" % length, value):
|
|
raise ValueError("无效的账号或会话编号")
|
|
return value
|
|
|
|
|
|
def _unlinked(path):
|
|
path = Path(path)
|
|
if path.is_symlink() or getattr(path, "is_junction", lambda: False)():
|
|
raise ValueError("Web 状态目录含链接路径,已停止操作")
|
|
return path
|
|
|
|
|
|
def atomic_json(path, value):
|
|
"""Write a complete JSON record with owner-only permissions and replacement."""
|
|
path = _unlinked(path)
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
temporary = path.with_name(path.name + "." + uuid.uuid4().hex + ".tmp")
|
|
descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
|
try:
|
|
with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
|
|
json.dump(value, stream, ensure_ascii=False, allow_nan=False, separators=(",", ":"))
|
|
stream.flush()
|
|
os.fsync(stream.fileno())
|
|
temporary.replace(path)
|
|
finally:
|
|
temporary.unlink(missing_ok=True)
|
|
|
|
|
|
def session_identity(session):
|
|
owner = session.account_id or session.server_url.rstrip("/")
|
|
raw = json.dumps([owner, session.channel, session.platform, session.server_id, session.role_id], separators=(",", ":"))
|
|
return hashlib.sha256(raw.encode("utf-8")).hexdigest()
|
|
|
|
|
|
class WorkspaceLock:
|
|
"""Hold the Web data root exclusively, on Windows as well as Linux."""
|
|
|
|
def __init__(self, root):
|
|
self.path = _unlinked(Path(root) / "workspace.lock")
|
|
self.stream = self.path.open("a+b")
|
|
self.stream.seek(0)
|
|
if self.path.stat().st_size == 0:
|
|
self.stream.write(b"\0")
|
|
self.stream.flush()
|
|
self.stream.seek(0)
|
|
try:
|
|
if os.name == "nt":
|
|
import msvcrt
|
|
msvcrt.locking(self.stream.fileno(), msvcrt.LK_NBLCK, 1)
|
|
else:
|
|
import fcntl
|
|
fcntl.flock(self.stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
except OSError:
|
|
self.stream.close()
|
|
raise RuntimeError("Web 数据目录已由另一个服务实例使用") from None
|
|
|
|
def close(self):
|
|
if self.stream.closed:
|
|
return
|
|
try:
|
|
self.stream.seek(0)
|
|
if os.name == "nt":
|
|
import msvcrt
|
|
msvcrt.locking(self.stream.fileno(), msvcrt.LK_UNLCK, 1)
|
|
else:
|
|
import fcntl
|
|
fcntl.flock(self.stream.fileno(), fcntl.LOCK_UN)
|
|
finally:
|
|
self.stream.close()
|
|
|
|
|
|
class WebStore:
|
|
def __init__(self, root):
|
|
candidate = Path(root).absolute()
|
|
for parent in (candidate, *candidate.parents):
|
|
_unlinked(parent)
|
|
self.root = candidate.resolve()
|
|
self.root.mkdir(parents=True, exist_ok=True)
|
|
self.lock = threading.RLock()
|
|
self.workspace_lock = WorkspaceLock(self.root)
|
|
try:
|
|
self.profiles = _unlinked(self.root / "profiles")
|
|
self.profiles.mkdir(exist_ok=True)
|
|
self.fernet = Fernet(self._key())
|
|
except Exception:
|
|
self.workspace_lock.close()
|
|
raise
|
|
|
|
def _key(self):
|
|
path = _unlinked(self.root / "web.key")
|
|
if not path.exists():
|
|
if next(self.profiles.glob("*/credentials.fernet"), None) or next(self.profiles.glob("*/sessions/*.fernet"), None):
|
|
raise ValueError("缺少 Web 加密密钥,无法恢复已保存登录;请恢复原密钥")
|
|
try:
|
|
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
|
except FileExistsError:
|
|
pass
|
|
else:
|
|
with os.fdopen(descriptor, "wb") as stream:
|
|
stream.write(Fernet.generate_key())
|
|
stream.flush()
|
|
os.fsync(stream.fileno())
|
|
os.chmod(path, 0o600)
|
|
try:
|
|
raw = path.read_bytes()
|
|
Fernet(raw)
|
|
except (OSError, ValueError):
|
|
raise ValueError("Web 加密密钥无法读取,请恢复原密钥") from None
|
|
return raw
|
|
|
|
def profile(self, identifier):
|
|
folder = _unlinked(self.profiles / _identifier(identifier))
|
|
if folder.resolve() != folder or self.profiles.resolve() != self.profiles:
|
|
raise ValueError("账号工作区路径不合法")
|
|
return folder
|
|
|
|
def accounts(self):
|
|
with self.lock:
|
|
path = _unlinked(self.root / "accounts.json")
|
|
if not path.exists():
|
|
return []
|
|
value = json.loads(path.read_text(encoding="utf-8"))
|
|
if not isinstance(value, dict) or value.get("schema") != 1 or not isinstance(value.get("accounts"), list):
|
|
raise ValueError("Web 账号目录格式错误")
|
|
entries, seen = [], set()
|
|
for row in value["accounts"]:
|
|
if not isinstance(row, dict) or set(row) != {"id", "label", "demo"}:
|
|
raise ValueError("Web 账号目录格式错误")
|
|
identifier = _identifier(row["id"])
|
|
if identifier in seen or not isinstance(row["label"], str) or type(row["demo"]) is not bool:
|
|
raise ValueError("Web 账号目录格式错误")
|
|
self.profile(identifier)
|
|
seen.add(identifier)
|
|
entries.append(dict(row))
|
|
return entries
|
|
|
|
def save_accounts(self, entries):
|
|
with self.lock:
|
|
atomic_json(self.root / "accounts.json", {"schema": 1, "accounts": entries})
|
|
|
|
def secure(self, identifier):
|
|
return SecureStore(self, identifier)
|
|
|
|
def role_root(self, identifier, identity=None, *, demo=False):
|
|
folder = self.profile(identifier)
|
|
if identity is not None:
|
|
roles = _unlinked(folder / "roles")
|
|
result = _unlinked(roles / _identifier(identity, 64))
|
|
else:
|
|
result = _unlinked(folder / ("demo" if demo else "disconnected"))
|
|
if not result.resolve().is_relative_to(folder):
|
|
raise ValueError("角色工作区路径不合法")
|
|
result.mkdir(parents=True, exist_ok=True)
|
|
return result
|
|
|
|
def load_config(self, folder):
|
|
path = _unlinked(Path(folder) / "settings.json")
|
|
if not path.exists():
|
|
return None
|
|
value = json.loads(path.read_text(encoding="utf-8"))
|
|
if not isinstance(value, dict) or value.get("schema") != 1 or type(value.get("revision")) is not int or not isinstance(value.get("config"), dict):
|
|
raise ValueError("Web 策略文件格式错误")
|
|
return value
|
|
|
|
def save_config(self, folder, config, revision):
|
|
atomic_json(Path(folder) / "settings.json", {"schema": 1, "revision": revision, "config": config})
|
|
|
|
def remove_profile(self, identifier):
|
|
"""Validate the whole tree before deleting only this UUID profile."""
|
|
folder = self.profile(identifier)
|
|
if not folder.exists():
|
|
return
|
|
for current, directories, files in os.walk(folder, followlinks=False):
|
|
for name in (*directories, *files):
|
|
target = _unlinked(Path(current) / name)
|
|
if not target.resolve().is_relative_to(folder):
|
|
raise ValueError("账号工作区含越界路径,已停止删除")
|
|
shutil.rmtree(folder)
|
|
|
|
def close(self):
|
|
self.workspace_lock.close()
|
|
|
|
|
|
class SecureStore:
|
|
"""Account-scoped Fernet records; public session entries are explicit fields."""
|
|
|
|
def __init__(self, workspace, identifier):
|
|
self.workspace = workspace
|
|
self.profile_root = workspace.profile(identifier)
|
|
self.profile_root.mkdir(exist_ok=True)
|
|
self.folder = _unlinked(self.profile_root / "sessions")
|
|
self.lock = threading.RLock()
|
|
|
|
def _write(self, path, value):
|
|
encrypted = self.workspace.fernet.encrypt(json.dumps(value, ensure_ascii=False, allow_nan=False).encode("utf-8"))
|
|
atomic_json(path, {"schema": 1, "scheme": "fernet", "protected": encrypted.decode("ascii")})
|
|
|
|
def _read(self, path):
|
|
try:
|
|
record = json.loads(_unlinked(path).read_text(encoding="utf-8"))
|
|
if record.get("schema") != 1 or record.get("scheme") != "fernet":
|
|
raise ValueError
|
|
return json.loads(self.workspace.fernet.decrypt(record["protected"].encode("ascii")))
|
|
except (InvalidToken, KeyError, ValueError, TypeError, AttributeError, UnicodeError):
|
|
raise ValueError("Web 加密记录无法读取,请恢复正确密钥或重新登录") from None
|
|
|
|
def save_credentials(self, account, password, remember=True):
|
|
with self.lock:
|
|
self._write(self.profile_root / "credentials.fernet", {"remember": bool(remember),
|
|
"account": str(account) if remember else "", "password": str(password) if remember else ""})
|
|
|
|
def load_credentials(self):
|
|
with self.lock:
|
|
path = self.profile_root / "credentials.fernet"
|
|
if not path.exists():
|
|
return False, "", ""
|
|
value = self._read(path)
|
|
if type(value.get("remember")) is not bool or not isinstance(value.get("account"), str) or not isinstance(value.get("password"), str):
|
|
raise ValueError("Web 登录记录格式错误")
|
|
return value["remember"], value["account"], value["password"]
|
|
|
|
def device(self):
|
|
with self.lock:
|
|
path = self.profile_root / "device.fernet"
|
|
if path.exists():
|
|
return self._read(path)["device_id"]
|
|
device = str(uuid.uuid4())
|
|
self._write(path, {"device_id": device})
|
|
return device
|
|
|
|
def set_active(self, identity):
|
|
with self.lock:
|
|
path = self.profile_root / "active.fernet"
|
|
if identity is None:
|
|
_unlinked(path).unlink(missing_ok=True)
|
|
else:
|
|
self._write(path, {"session_id": _identifier(identity, 64)})
|
|
|
|
def active(self):
|
|
with self.lock:
|
|
path = self.profile_root / "active.fernet"
|
|
if not path.exists():
|
|
return None
|
|
return _identifier(self._read(path)["session_id"], 64)
|
|
|
|
def save(self, session, label):
|
|
if not session.token or not session.server_url or not session.role_id:
|
|
return None
|
|
identity = session_identity(session)
|
|
with self.lock:
|
|
self.folder.mkdir(exist_ok=True)
|
|
path = self.folder / (identity + ".fernet")
|
|
value = asdict(session)
|
|
if path.exists():
|
|
previous = self._read(path)["session"]
|
|
# Counters are never rolled back, including by an imported/stale object.
|
|
for field in ("reqid", "reqsid"):
|
|
value[field] = max(int(value[field]), int(previous.get(field, 0)))
|
|
setattr(session, field, value[field])
|
|
self._write(path, {"session_id": identity, "label": str(label),
|
|
"saved_at": datetime.now(timezone.utc).isoformat(timespec="seconds"), "session": value})
|
|
return identity
|
|
|
|
def entries(self):
|
|
with self.lock:
|
|
_unlinked(self.folder)
|
|
result = []
|
|
for path in self.folder.glob("*.fernet"):
|
|
_identifier(path.stem, 64)
|
|
value = self._read(path)
|
|
if value.get("session_id") != path.stem:
|
|
raise ValueError("Web 会话编号不一致")
|
|
result.append({field: value[field] for field in ("session_id", "label", "saved_at")})
|
|
return sorted(result, key=lambda row: row["saved_at"], reverse=True)
|
|
|
|
def load(self, identifier):
|
|
identifier = _identifier(identifier, 64)
|
|
with self.lock:
|
|
value = self._read(_unlinked(self.folder) / (identifier + ".fernet"))
|
|
session = Session(**value["session"])
|
|
if session_identity(session) != identifier or not session.token or not session.role_id:
|
|
raise ValueError("保存的账号、区服或角色信息不一致")
|
|
return session
|
|
|
|
def remove(self, identifier):
|
|
with self.lock:
|
|
self.load(identifier)
|
|
(self.folder / (identifier + ".fernet")).unlink()
|
|
|
|
def forget(self):
|
|
with self.lock:
|
|
_unlinked(self.folder)
|
|
for path in self.folder.glob("*.fernet"):
|
|
_identifier(path.stem, 64)
|
|
_unlinked(path)
|
|
for path in self.folder.glob("*.fernet"):
|
|
path.unlink()
|
|
_unlinked(self.profile_root / "credentials.fernet").unlink(missing_ok=True)
|
|
_unlinked(self.profile_root / "active.fernet").unlink(missing_ok=True)
|