664 lines
26 KiB
Python
664 lines
26 KiB
Python
from __future__ import annotations
|
||
|
||
import base64
|
||
import hmac
|
||
import hashlib
|
||
import os
|
||
import secrets
|
||
import time
|
||
from html import escape
|
||
from pathlib import Path
|
||
from typing import Any
|
||
from urllib.parse import urljoin
|
||
|
||
from fastapi import FastAPI, File, Form, Request, UploadFile
|
||
from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, RedirectResponse, Response
|
||
from pydantic import BaseModel
|
||
|
||
from license_server.core import LicenseActionResult, LicenseService, UpdateManifest
|
||
|
||
|
||
RATE_LIMIT_WINDOW_SECONDS = 60
|
||
RATE_LIMIT_MAX_REQUESTS = 30
|
||
ADMIN_LOGIN_RATE_LIMIT_MAX_REQUESTS = 10
|
||
VERIFY_LICENSE_RATE_LIMIT_MAX_REQUESTS = 600
|
||
ADMIN_CSRF_COOKIE = "dygj_admin_csrf"
|
||
ADMIN_SESSION_COOKIE = "dygj_admin_session"
|
||
ADMIN_SESSION_SECONDS = 12 * 60 * 60
|
||
|
||
|
||
class ActivateRequest(BaseModel):
|
||
card_key: str
|
||
machine_fingerprint: str
|
||
|
||
|
||
class VerifyRequest(BaseModel):
|
||
card_key: str
|
||
machine_fingerprint: str
|
||
|
||
|
||
class VerifyLicenseRequest(BaseModel):
|
||
license: dict[str, Any]
|
||
|
||
|
||
def result_response(result: LicenseActionResult) -> JSONResponse:
|
||
body: dict[str, Any] = {
|
||
"ok": result.ok,
|
||
"reason": result.reason,
|
||
"message": result.message,
|
||
}
|
||
if result.license_doc is not None:
|
||
body["license"] = result.license_doc
|
||
if result.expires_at is not None:
|
||
body["expires_at"] = result.expires_at.isoformat().replace("+00:00", "Z")
|
||
status = 200 if result.ok else _status_for_reason(result.reason)
|
||
return JSONResponse(body, status_code=status)
|
||
|
||
|
||
def _status_for_reason(reason: str) -> int:
|
||
if reason == "rate_limited":
|
||
return 429
|
||
if reason == "not_found":
|
||
return 404
|
||
if reason in {"revoked", "inactive", "device_limit", "machine_mismatch"}:
|
||
return 403
|
||
if reason in {"missing_machine", "not_activated"}:
|
||
return 400
|
||
return 400
|
||
|
||
|
||
def load_private_key_pem() -> bytes:
|
||
raw_path = str(os.environ.get("DYGJ_LICENSE_PRIVATE_KEY_PATH") or "").strip()
|
||
if raw_path:
|
||
return Path(raw_path).read_bytes()
|
||
raw_pem = str(os.environ.get("DYGJ_LICENSE_PRIVATE_KEY_PEM") or "").strip()
|
||
if raw_pem:
|
||
return raw_pem.encode("utf-8")
|
||
raise RuntimeError("missing DYGJ_LICENSE_PRIVATE_KEY_PATH or DYGJ_LICENSE_PRIVATE_KEY_PEM")
|
||
|
||
|
||
def create_service_from_env() -> LicenseService:
|
||
db_path = os.environ.get("DYGJ_LICENSE_DB_PATH") or "/opt/douyin-license-server/data/app.db"
|
||
return LicenseService(db_path=db_path, private_key_pem=load_private_key_pem())
|
||
|
||
|
||
def admin_token_from_env() -> str:
|
||
return str(os.environ.get("DYGJ_LICENSE_ADMIN_TOKEN") or "").strip()
|
||
|
||
|
||
def _env_bool(name: str, default: bool = False) -> bool:
|
||
raw = str(os.environ.get(name) or "").strip().lower()
|
||
if raw in {"1", "true", "yes", "y", "on"}:
|
||
return True
|
||
if raw in {"0", "false", "no", "n", "off"}:
|
||
return False
|
||
return default
|
||
|
||
|
||
def _admin_allowed(request: Request, admin_token: str) -> bool:
|
||
expected = str(admin_token or "").strip()
|
||
if not expected:
|
||
return False
|
||
session = str(request.cookies.get(ADMIN_SESSION_COOKIE) or "").strip()
|
||
sessions: dict[str, float] = request.app.state.admin_sessions
|
||
expires_at = sessions.get(_session_hash(session), 0.0)
|
||
if session and expires_at > time.time():
|
||
return True
|
||
auth = str(request.headers.get("authorization") or "").strip()
|
||
if hmac.compare_digest(auth, f"Bearer {expected}"):
|
||
return True
|
||
if not auth.lower().startswith("basic "):
|
||
return False
|
||
try:
|
||
decoded = base64.b64decode(auth.split(" ", 1)[1], validate=True).decode("utf-8")
|
||
except Exception:
|
||
return False
|
||
_user, sep, supplied = decoded.partition(":")
|
||
if not sep:
|
||
return False
|
||
return hmac.compare_digest(supplied, expected)
|
||
|
||
|
||
def _session_hash(raw: str) -> str:
|
||
return hashlib.sha256(str(raw or "").encode("utf-8")).hexdigest()
|
||
|
||
|
||
def _new_admin_session(request: Request) -> str:
|
||
raw = secrets.token_urlsafe(32)
|
||
request.app.state.admin_sessions[_session_hash(raw)] = time.time() + ADMIN_SESSION_SECONDS
|
||
return raw
|
||
|
||
|
||
def _drop_admin_session(request: Request) -> None:
|
||
raw = str(request.cookies.get(ADMIN_SESSION_COOKIE) or "").strip()
|
||
if raw:
|
||
request.app.state.admin_sessions.pop(_session_hash(raw), None)
|
||
|
||
|
||
def _admin_forbidden() -> HTMLResponse:
|
||
return _login_page("请先登录后台。", status_code=403)
|
||
|
||
|
||
def _login_page(message: str = "", *, status_code: int = 200) -> HTMLResponse:
|
||
message_html = f"<p class='msg'>{escape(message)}</p>" if message else ""
|
||
html = f"""<!doctype html>
|
||
<html lang="zh-CN">
|
||
<head>
|
||
<meta charset="utf-8" />
|
||
<title>卡密后台登录</title>
|
||
<style>
|
||
body {{ margin: 0; min-height: 100vh; display: grid; place-items: center; font-family: "Microsoft YaHei", sans-serif; background: radial-gradient(circle at top left, #dbeafe, transparent 32%), #0f172a; color: #0f172a; }}
|
||
main {{ width: min(420px, calc(100vw - 32px)); background: #fff; border-radius: 24px; padding: 28px; box-shadow: 0 28px 80px rgba(15, 23, 42, .35); }}
|
||
h1 {{ margin: 0 0 8px; font-size: 28px; }}
|
||
p {{ color: #64748b; margin: 0 0 18px; }}
|
||
label {{ display: block; color: #475569; font-size: 14px; }}
|
||
input {{ width: 100%; box-sizing: border-box; padding: 12px 14px; border: 1px solid #cbd5e1; border-radius: 12px; margin-top: 8px; font-size: 15px; }}
|
||
button {{ width: 100%; margin-top: 16px; padding: 12px 16px; cursor: pointer; border: 0; border-radius: 12px; background: #2563eb; color: white; font-weight: 800; font-size: 15px; }}
|
||
.msg {{ padding: 10px 12px; background: #fff7ed; border: 1px solid #fed7aa; border-radius: 10px; color: #9a3412; }}
|
||
.hint {{ font-size: 13px; color: #64748b; margin-top: 14px; }}
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<main>
|
||
<h1>卡密后台登录</h1>
|
||
<p>请输入服务器管理员 token。</p>
|
||
{message_html}
|
||
<form method="post" action="/admin/login">
|
||
<label>管理员 token
|
||
<input name="admin_token" type="password" autocomplete="current-password" autofocus />
|
||
</label>
|
||
<button type="submit">登录后台</button>
|
||
</form>
|
||
<div class="hint">登录后会写入 HttpOnly 会话 cookie,不会把 token 放进 URL。</div>
|
||
</main>
|
||
</body>
|
||
</html>"""
|
||
return HTMLResponse(html, status_code=status_code)
|
||
|
||
|
||
def _csrf_token(request: Request) -> str:
|
||
raw = str(request.cookies.get(ADMIN_CSRF_COOKIE) or "").strip()
|
||
if len(raw) >= 32:
|
||
return raw
|
||
return secrets.token_urlsafe(24)
|
||
|
||
|
||
def _csrf_allowed(request: Request, token: str) -> bool:
|
||
cookie = str(request.cookies.get(ADMIN_CSRF_COOKIE) or "").strip()
|
||
supplied = str(token or "").strip()
|
||
return bool(cookie and supplied and hmac.compare_digest(cookie, supplied))
|
||
|
||
|
||
def _rate_limit_key(request: Request, scope: str) -> str:
|
||
host = request.client.host if request.client else "unknown"
|
||
if getattr(request.app.state, "trust_forwarded_for", False):
|
||
forwarded = str(request.headers.get("x-forwarded-for") or "").split(",", 1)[0].strip()
|
||
host = forwarded or host
|
||
return f"{scope}:{host}"
|
||
|
||
|
||
def _rate_limited(request: Request, scope: str, *, max_requests: int | None = None) -> bool:
|
||
threshold = RATE_LIMIT_MAX_REQUESTS if max_requests is None else int(max_requests)
|
||
now = time.monotonic()
|
||
key = _rate_limit_key(request, scope)
|
||
buckets: dict[str, list[float]] = request.app.state.rate_limit_buckets
|
||
recent = [ts for ts in buckets.get(key, []) if now - ts < RATE_LIMIT_WINDOW_SECONDS]
|
||
if len(recent) >= threshold:
|
||
buckets[key] = recent
|
||
return True
|
||
recent.append(now)
|
||
buckets[key] = recent
|
||
return False
|
||
|
||
|
||
def _public_base_url(request: Request) -> str:
|
||
configured = str(os.environ.get("DYGJ_LICENSE_PUBLIC_BASE_URL") or "").strip()
|
||
if configured:
|
||
return configured.rstrip("/")
|
||
return str(request.base_url).rstrip("/")
|
||
|
||
|
||
def _signed_update_manifest(service: LicenseService, request: Request) -> dict[str, Any]:
|
||
manifest = service.load_update_manifest()
|
||
if not manifest.enabled:
|
||
payload: dict[str, Any] = {
|
||
"enabled": False,
|
||
"version": "0.0.0",
|
||
"force": False,
|
||
"message": "no update published",
|
||
}
|
||
payload["signature"] = service.sign_payload(payload)
|
||
return payload
|
||
|
||
download_path = f"/api/v1/update/download/{manifest.filename}"
|
||
payload = {
|
||
"enabled": True,
|
||
"version": manifest.version,
|
||
"url": urljoin(_public_base_url(request) + "/", download_path.lstrip("/")),
|
||
"filename": manifest.filename,
|
||
"sha256": manifest.sha256,
|
||
"force": manifest.force,
|
||
"notes": manifest.notes,
|
||
"published_at": manifest.published_at,
|
||
}
|
||
payload["signature"] = service.sign_payload(payload)
|
||
return payload
|
||
|
||
|
||
def _update_summary_html(manifest: UpdateManifest) -> str:
|
||
status = "已开启" if manifest.enabled else "未发布/已关闭"
|
||
sha = manifest.sha256[:12] + "..." if manifest.sha256 else "-"
|
||
file_name = manifest.filename or "-"
|
||
published = manifest.published_at or "-"
|
||
return (
|
||
"<div class='update-state'>"
|
||
f"<b>{escape(status)}</b>"
|
||
f"<span>版本:<code>{escape(manifest.version or '0.0.0')}</code></span>"
|
||
f"<span>文件:<code>{escape(file_name)}</code></span>"
|
||
f"<span>SHA256:<code>{escape(sha)}</code></span>"
|
||
f"<span>发布时间:{escape(published)}</span>"
|
||
"</div>"
|
||
)
|
||
|
||
|
||
def _admin_page(
|
||
service: LicenseService,
|
||
csrf_token: str,
|
||
message: str = "",
|
||
cards: list[str] | None = None,
|
||
) -> HTMLResponse:
|
||
csrf_attr = escape(csrf_token, quote=True)
|
||
stats = service.stats()
|
||
card_rows = service.list_cards(limit=50)
|
||
audit_rows = service.audit_logs(limit=30)
|
||
update_manifest = service.load_update_manifest()
|
||
update_html = _update_summary_html(update_manifest)
|
||
created_rows = "".join(
|
||
f"<li><code>{escape(card)}</code></li>" for card in (cards or [])
|
||
)
|
||
table_rows = "".join(
|
||
"<tr>"
|
||
f"<td>#{row.id}</td>"
|
||
f"<td><code>{escape(row.code_hint)}</code></td>"
|
||
f"<td><span class='status {escape(row.status)}'>{escape(row.status)}</span></td>"
|
||
f"<td>{row.days}</td>"
|
||
f"<td>{row.activation_count}/{row.max_devices}</td>"
|
||
f"<td>{escape(row.customer)}</td>"
|
||
f"<td>{escape(row.created_at)}</td>"
|
||
f"<td>{escape(row.last_seen_at)}</td>"
|
||
"</tr>"
|
||
for row in card_rows
|
||
)
|
||
audit_html = "".join(
|
||
"<tr>"
|
||
f"<td>{escape(row.created_at)}</td>"
|
||
f"<td>{escape(row.action)}</td>"
|
||
f"<td><code>{escape(row.code_hint)}</code></td>"
|
||
f"<td><code>{escape(row.machine_fingerprint[:16])}</code></td>"
|
||
f"<td>{escape(row.reason)}</td>"
|
||
"</tr>"
|
||
for row in audit_rows
|
||
)
|
||
message_html = f"<p class='msg'>{escape(message)}</p>" if message else ""
|
||
html = f"""<!doctype html>
|
||
<html lang="zh-CN">
|
||
<head>
|
||
<meta charset="utf-8" />
|
||
<title>卡密管理</title>
|
||
<style>
|
||
body {{ margin: 0; font-family: "Microsoft YaHei", sans-serif; background: #eef2f7; color: #111827; }}
|
||
main {{ max-width: 1180px; margin: 28px auto; padding: 0 18px 32px; }}
|
||
header {{ display: flex; justify-content: space-between; align-items: end; gap: 16px; margin-bottom: 18px; }}
|
||
h1 {{ margin: 0; font-size: 30px; }}
|
||
h2 {{ margin: 0 0 14px; font-size: 18px; }}
|
||
.sub {{ color: #64748b; margin-top: 6px; }}
|
||
.grid {{ display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; }}
|
||
.stat {{ background: linear-gradient(135deg, #0f172a, #1f2937); color: white; border-radius: 16px; padding: 18px; }}
|
||
.stat b {{ display: block; font-size: 28px; margin-top: 8px; }}
|
||
section {{ background: #fff; border: 1px solid #e5e7eb; border-radius: 16px; padding: 18px; margin: 14px 0; box-shadow: 0 12px 30px rgba(15, 23, 42, .06); }}
|
||
form.inline {{ display: grid; grid-template-columns: repeat(5, minmax(120px, 1fr)); gap: 10px; align-items: end; }}
|
||
form.update {{ display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 10px; align-items: end; }}
|
||
label {{ display: block; color: #475569; font-size: 13px; }}
|
||
input {{ width: 100%; box-sizing: border-box; padding: 10px 12px; border: 1px solid #cbd5e1; border-radius: 10px; margin-top: 5px; }}
|
||
button {{ padding: 10px 16px; cursor: pointer; border: 0; border-radius: 10px; background: #2563eb; color: white; font-weight: 700; }}
|
||
button.danger {{ background: #dc2626; }}
|
||
button.secondary {{ background: #334155; }}
|
||
code {{ font-size: 14px; }}
|
||
table {{ width: 100%; border-collapse: collapse; font-size: 14px; }}
|
||
th, td {{ text-align: left; padding: 10px; border-bottom: 1px solid #e5e7eb; vertical-align: top; }}
|
||
th {{ color: #475569; background: #f8fafc; }}
|
||
.status {{ padding: 3px 8px; border-radius: 999px; font-size: 12px; background: #e2e8f0; }}
|
||
.status.active {{ background: #dcfce7; color: #166534; }}
|
||
.status.revoked {{ background: #fee2e2; color: #991b1b; }}
|
||
.msg {{ padding: 10px 12px; background: #ecfdf5; border: 1px solid #a7f3d0; border-radius: 8px; }}
|
||
.cards {{ display: grid; grid-template-columns: 1fr 1fr; gap: 14px; }}
|
||
.update-state {{ display: flex; flex-wrap: wrap; gap: 10px 16px; padding: 12px; border-radius: 12px; background: #f8fafc; border: 1px solid #e2e8f0; margin-bottom: 12px; }}
|
||
.help {{ margin-top: 8px; color: #64748b; font-size: 13px; }}
|
||
@media (max-width: 860px) {{ .grid, .cards, form.inline, form.update {{ grid-template-columns: 1fr; }} }}
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<main>
|
||
<header>
|
||
<div>
|
||
<h1>卡密管理</h1>
|
||
<div class="sub">生成、禁用、解绑设备,并查看最近激活日志。</div>
|
||
</div>
|
||
<form method="post" action="/admin/logout"><button class="secondary" type="submit">退出登录</button></form>
|
||
</header>
|
||
<div class="grid">
|
||
<div class="stat">总卡密 <b>{stats["total"]}</b></div>
|
||
<div class="stat">活跃卡密 <b>{stats["active"]}</b></div>
|
||
<div class="stat">已禁用 <b>{stats["revoked"]}</b></div>
|
||
<div class="stat">已绑定设备 <b>{stats["activations"]}</b></div>
|
||
</div>
|
||
{message_html}
|
||
<section>
|
||
<h2>生成卡密</h2>
|
||
<form class="inline" method="post" action="/admin/create">
|
||
<input type="hidden" name="csrf_token" value="{csrf_attr}" />
|
||
<label>天数 <input name="days" value="30" /></label>
|
||
<label>数量 <input name="count" value="1" /></label>
|
||
<label>设备数 <input name="max_devices" value="1" /></label>
|
||
<label>备注/客户 <input name="customer" value="" /></label>
|
||
<button type="submit">生成</button>
|
||
</form>
|
||
<ul>{created_rows}</ul>
|
||
</section>
|
||
<div class="cards">
|
||
<section>
|
||
<h2>禁用卡密</h2>
|
||
<form method="post" action="/admin/revoke">
|
||
<input type="hidden" name="csrf_token" value="{csrf_attr}" />
|
||
<label>卡密 <input name="card_key" placeholder="DG-..." /></label>
|
||
<button class="danger" type="submit">禁用</button>
|
||
</form>
|
||
</section>
|
||
<section>
|
||
<h2>解绑设备</h2>
|
||
<form method="post" action="/admin/unbind">
|
||
<input type="hidden" name="csrf_token" value="{csrf_attr}" />
|
||
<label>卡密 <input name="card_key" placeholder="DG-..." /></label>
|
||
<button class="secondary" type="submit">解绑</button>
|
||
</form>
|
||
</section>
|
||
</div>
|
||
<section>
|
||
<h2>在线更新</h2>
|
||
{update_html}
|
||
<form class="update" method="post" action="/admin/update/publish" enctype="multipart/form-data">
|
||
<input type="hidden" name="csrf_token" value="{csrf_attr}" />
|
||
<label>新版本号 <input name="version" placeholder="例如 3.3.4" /></label>
|
||
<label>说明 <input name="notes" placeholder="更新内容,可留空" /></label>
|
||
<label>安装包 exe <input name="installer" type="file" accept=".exe" /></label>
|
||
<label>强制更新 <input name="force" value="1" /></label>
|
||
<button type="submit">上传并发布</button>
|
||
</form>
|
||
<form method="post" action="/admin/update/disable" style="margin-top:10px">
|
||
<input type="hidden" name="csrf_token" value="{csrf_attr}" />
|
||
<button class="secondary" type="submit">关闭更新</button>
|
||
</form>
|
||
<div class="help">客户端读取 <code>/api/v1/update/manifest</code>,manifest 会用服务端私钥签名,安装包下载后再做 SHA256 校验。</div>
|
||
</section>
|
||
<section>
|
||
<h2>最近卡密</h2>
|
||
<table>
|
||
<thead><tr><th>ID</th><th>卡密</th><th>状态</th><th>天数</th><th>设备</th><th>客户</th><th>创建时间</th><th>最后在线</th></tr></thead>
|
||
<tbody>{table_rows}</tbody>
|
||
</table>
|
||
</section>
|
||
<section>
|
||
<h2>最近审计日志</h2>
|
||
<table>
|
||
<thead><tr><th>时间</th><th>动作</th><th>卡密</th><th>机器</th><th>结果</th></tr></thead>
|
||
<tbody>{audit_html}</tbody>
|
||
</table>
|
||
</section>
|
||
</main>
|
||
</body>
|
||
</html>"""
|
||
return HTMLResponse(html)
|
||
|
||
|
||
def create_app(
|
||
*,
|
||
service: LicenseService | None = None,
|
||
admin_token: str | None = None,
|
||
) -> FastAPI:
|
||
docs_enabled = _env_bool("DYGJ_LICENSE_ENABLE_DOCS", default=False)
|
||
app = FastAPI(
|
||
title="Douyin Guaji License Server",
|
||
docs_url="/docs" if docs_enabled else None,
|
||
redoc_url="/redoc" if docs_enabled else None,
|
||
openapi_url="/openapi.json" if docs_enabled else None,
|
||
)
|
||
app.state.license_service = service
|
||
app.state.admin_token = admin_token if admin_token is not None else admin_token_from_env()
|
||
app.state.secure_cookies = _env_bool("DYGJ_LICENSE_SECURE_COOKIES", default=False)
|
||
app.state.trust_forwarded_for = _env_bool("DYGJ_LICENSE_TRUST_FORWARDED_FOR", default=False)
|
||
app.state.rate_limit_buckets = {}
|
||
app.state.admin_sessions = {}
|
||
|
||
def get_service() -> LicenseService:
|
||
if app.state.license_service is None:
|
||
app.state.license_service = create_service_from_env()
|
||
return app.state.license_service
|
||
|
||
@app.get("/api/v1/health")
|
||
def health() -> dict[str, Any]:
|
||
return {"ok": True, "service": "douyin-license-server"}
|
||
|
||
@app.post("/api/v1/activate")
|
||
def activate(request: Request, req: ActivateRequest) -> JSONResponse:
|
||
if _rate_limited(request, "activate"):
|
||
return result_response(LicenseActionResult(False, "rate_limited", "请求过于频繁,请稍后再试"))
|
||
return result_response(
|
||
get_service().activate(
|
||
req.card_key,
|
||
machine_fingerprint=req.machine_fingerprint,
|
||
)
|
||
)
|
||
|
||
@app.post("/api/v1/verify")
|
||
def verify(request: Request, req: VerifyRequest) -> JSONResponse:
|
||
if _rate_limited(request, "verify"):
|
||
return result_response(LicenseActionResult(False, "rate_limited", "请求过于频繁,请稍后再试"))
|
||
return result_response(
|
||
get_service().verify(
|
||
req.card_key,
|
||
machine_fingerprint=req.machine_fingerprint,
|
||
)
|
||
)
|
||
|
||
@app.post("/api/v1/verify_license")
|
||
def verify_license(request: Request, req: VerifyLicenseRequest) -> JSONResponse:
|
||
if _rate_limited(request, "verify_license", max_requests=VERIFY_LICENSE_RATE_LIMIT_MAX_REQUESTS):
|
||
return result_response(LicenseActionResult(False, "rate_limited", "请求过于频繁,请稍后再试"))
|
||
return result_response(get_service().verify_license_doc(req.license))
|
||
|
||
@app.get("/api/v1/update/manifest")
|
||
def update_manifest(request: Request) -> JSONResponse:
|
||
return JSONResponse(_signed_update_manifest(get_service(), request))
|
||
|
||
@app.get("/api/v1/update/download/{filename}")
|
||
def update_download(filename: str) -> Response:
|
||
service = get_service()
|
||
manifest = service.load_update_manifest()
|
||
safe_name = Path(str(filename or "")).name
|
||
if not manifest.enabled or safe_name != manifest.filename:
|
||
return JSONResponse({"ok": False, "reason": "not_found"}, status_code=404)
|
||
target = service.update_dir / manifest.filename
|
||
if not target.exists():
|
||
return JSONResponse({"ok": False, "reason": "file_missing"}, status_code=404)
|
||
return FileResponse(
|
||
target,
|
||
media_type="application/octet-stream",
|
||
filename=manifest.filename,
|
||
)
|
||
|
||
@app.get("/admin")
|
||
def admin(request: Request) -> Response:
|
||
if not _admin_allowed(request, app.state.admin_token):
|
||
return RedirectResponse("/admin/login", status_code=303)
|
||
csrf = _csrf_token(request)
|
||
response = _admin_page(get_service(), csrf)
|
||
response.set_cookie(
|
||
ADMIN_CSRF_COOKIE,
|
||
csrf,
|
||
httponly=True,
|
||
samesite="lax",
|
||
secure=bool(app.state.secure_cookies),
|
||
)
|
||
return response
|
||
|
||
@app.get("/admin/login")
|
||
def admin_login_page() -> HTMLResponse:
|
||
return _login_page()
|
||
|
||
@app.post("/admin/login")
|
||
def admin_login(request: Request, admin_token: str = Form("")) -> HTMLResponse:
|
||
if _rate_limited(
|
||
request,
|
||
"admin_login",
|
||
max_requests=ADMIN_LOGIN_RATE_LIMIT_MAX_REQUESTS,
|
||
):
|
||
return _login_page("登录尝试过于频繁,请稍后再试。", status_code=429)
|
||
expected = str(app.state.admin_token or "").strip()
|
||
supplied = str(admin_token or "").strip()
|
||
if not expected or not hmac.compare_digest(supplied, expected):
|
||
return _login_page("管理员 token 不正确。", status_code=403)
|
||
session = _new_admin_session(request)
|
||
response = RedirectResponse("/admin", status_code=303)
|
||
response.set_cookie(
|
||
ADMIN_SESSION_COOKIE,
|
||
session,
|
||
max_age=ADMIN_SESSION_SECONDS,
|
||
httponly=True,
|
||
samesite="lax",
|
||
secure=bool(app.state.secure_cookies),
|
||
)
|
||
return response
|
||
|
||
@app.post("/admin/logout")
|
||
def admin_logout(request: Request) -> RedirectResponse:
|
||
_drop_admin_session(request)
|
||
response = RedirectResponse("/admin/login", status_code=303)
|
||
response.delete_cookie(ADMIN_SESSION_COOKIE)
|
||
response.delete_cookie(ADMIN_CSRF_COOKIE)
|
||
return response
|
||
|
||
@app.post("/admin/create")
|
||
def admin_create(
|
||
request: Request,
|
||
csrf_token: str = Form(""),
|
||
days: int = Form(30),
|
||
count: int = Form(1),
|
||
max_devices: int = Form(1),
|
||
customer: str = Form(""),
|
||
) -> HTMLResponse:
|
||
if not _admin_allowed(request, app.state.admin_token):
|
||
return _admin_forbidden()
|
||
csrf = _csrf_token(request)
|
||
if not _csrf_allowed(request, csrf_token):
|
||
return _admin_page(get_service(), csrf, message="CSRF 校验失败,请刷新后台页面后重试")
|
||
try:
|
||
cards = get_service().create_cards(
|
||
days=days,
|
||
count=count,
|
||
max_devices=max_devices,
|
||
customer=customer,
|
||
)
|
||
message = f"已生成 {len(cards)} 个卡密,customer={customer}"
|
||
except ValueError as exc:
|
||
cards = []
|
||
message = f"参数错误:{exc}"
|
||
return _admin_page(
|
||
get_service(),
|
||
csrf,
|
||
message=message,
|
||
cards=[card.code for card in cards],
|
||
)
|
||
|
||
@app.post("/admin/revoke")
|
||
def admin_revoke(
|
||
request: Request,
|
||
csrf_token: str = Form(""),
|
||
card_key: str = Form(""),
|
||
) -> HTMLResponse:
|
||
if not _admin_allowed(request, app.state.admin_token):
|
||
return _admin_forbidden()
|
||
csrf = _csrf_token(request)
|
||
if not _csrf_allowed(request, csrf_token):
|
||
return _admin_page(get_service(), csrf, message="CSRF 校验失败,请刷新后台页面后重试")
|
||
ok = get_service().revoke(card_key)
|
||
msg = "已禁用" if ok else "卡密不存在"
|
||
return _admin_page(
|
||
get_service(),
|
||
csrf,
|
||
message=msg,
|
||
)
|
||
|
||
@app.post("/admin/unbind")
|
||
def admin_unbind(
|
||
request: Request,
|
||
csrf_token: str = Form(""),
|
||
card_key: str = Form(""),
|
||
) -> HTMLResponse:
|
||
if not _admin_allowed(request, app.state.admin_token):
|
||
return _admin_forbidden()
|
||
csrf = _csrf_token(request)
|
||
if not _csrf_allowed(request, csrf_token):
|
||
return _admin_page(get_service(), csrf, message="CSRF 校验失败,请刷新后台页面后重试")
|
||
count = get_service().unbind(card_key)
|
||
return _admin_page(
|
||
get_service(),
|
||
csrf,
|
||
message=f"已解绑 {count} 台设备",
|
||
)
|
||
|
||
@app.post("/admin/update/publish")
|
||
async def admin_update_publish(
|
||
request: Request,
|
||
csrf_token: str = Form(""),
|
||
version: str = Form(""),
|
||
notes: str = Form(""),
|
||
force: str = Form("1"),
|
||
installer: UploadFile = File(...),
|
||
) -> HTMLResponse:
|
||
if not _admin_allowed(request, app.state.admin_token):
|
||
return _admin_forbidden()
|
||
csrf = _csrf_token(request)
|
||
if not _csrf_allowed(request, csrf_token):
|
||
return _admin_page(get_service(), csrf, message="CSRF 校验失败,请刷新后台页面后重试")
|
||
try:
|
||
content = await installer.read()
|
||
manifest = get_service().publish_update(
|
||
version=version,
|
||
filename=installer.filename or "",
|
||
content=content,
|
||
force=str(force).strip() not in {"0", "false", "False", "否"},
|
||
notes=notes,
|
||
)
|
||
msg = f"已发布更新 V{manifest.version},文件={manifest.filename}"
|
||
except Exception as exc:
|
||
msg = f"发布更新失败:{exc}"
|
||
return _admin_page(get_service(), csrf, message=msg)
|
||
|
||
@app.post("/admin/update/disable")
|
||
def admin_update_disable(
|
||
request: Request,
|
||
csrf_token: str = Form(""),
|
||
) -> HTMLResponse:
|
||
if not _admin_allowed(request, app.state.admin_token):
|
||
return _admin_forbidden()
|
||
csrf = _csrf_token(request)
|
||
if not _csrf_allowed(request, csrf_token):
|
||
return _admin_page(get_service(), csrf, message="CSRF 校验失败,请刷新后台页面后重试")
|
||
get_service().disable_update()
|
||
return _admin_page(get_service(), csrf, message="已关闭自动更新发布")
|
||
|
||
return app
|
||
|
||
|
||
app = create_app()
|