feat: add redeem links for external sales

This commit is contained in:
Your Name committed 2026-06-24 18:49:21 +08:00
1 parent 8e8a14cf69
commit 3ab15e69f9
5 files changed
+510 -18

No files matched your search

+44
View File
@@ -16,6 +16,9 @@ GET /api/v1/health
POST /api/v1/activate
POST /api/v1/verify
POST /api/v1/verify_license
POST /api/v1/redeem/external/create
POST /api/v1/redeem/claim
GET /redeem/{token}
GET /api/v1/update/manifest
GET /api/v1/update/download/{filename}
GET /admin
@@ -32,6 +35,47 @@ GET /admin
成功后返回 `license` 字段,客户端本地验签通过才会写入 `license.dat`。
## 闲鱼自动发货接入
自动发货系统不要直接拿真实卡密,只调用服务端生成一次性兑换链接。买家打开兑换链接后,服务端才生成正式 `DG-` 卡密。
服务端先配置外部接口 token:
```bash
export DYGJ_LICENSE_EXTERNAL_API_TOKEN="一段足够长的随机密钥"
```
外部自动发货系统请求:
```text
POST /api/v1/redeem/external/create
Authorization: Bearer 一段足够长的随机密钥
```
```json
{
"platform": "xianyu",
"external_order_id": "闲鱼订单号",
"customer": "买家备注",
"days": 30,
"max_devices": 1,
"expires_hours": 72
}
```
返回只包含 `claim_url`,不返回真实卡密:
```json
{
"ok": true,
"claim_url": "https://dy.absfan.cn/redeem/xxxx",
"token_hint": "xxxx...xxxx",
"expires_at": "2026-06-24T12:00:00Z"
}
```
把 `claim_url` 通过闲鱼聊天自动发给买家即可。这个设计可以避免员工、闲鱼自动发货项目或聊天日志直接接触真实卡密库存。
## Docker 部署
```bash
+140
View File
@@ -3,6 +3,7 @@ from __future__ import annotations
import base64
import hmac
import hashlib
import json
import os
import secrets
import time
@@ -41,6 +42,19 @@ class VerifyLicenseRequest(BaseModel):
license: dict[str, Any]
class CreateRedeemRequest(BaseModel):
days: int
max_devices: int = 1
customer: str = ""
platform: str = ""
external_order_id: str = ""
expires_hours: int = 72
class ClaimRedeemRequest(BaseModel):
token: str
def result_response(result: LicenseActionResult) -> JSONResponse:
body: dict[str, Any] = {
"ok": result.ok,
@@ -86,6 +100,10 @@ def admin_token_from_env() -> str:
return str(os.environ.get("DYGJ_LICENSE_ADMIN_TOKEN") or "").strip()
def external_api_token_from_env() -> str:
return str(os.environ.get("DYGJ_LICENSE_EXTERNAL_API_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"}:
@@ -119,6 +137,17 @@ def _admin_allowed(request: Request, admin_token: str) -> bool:
return hmac.compare_digest(supplied, expected)
def _bearer_token_allowed(request: Request, expected_token: str) -> bool:
expected = str(expected_token or "").strip()
if not expected:
return False
auth = str(request.headers.get("authorization") or "").strip()
if not auth.lower().startswith("bearer "):
return False
supplied = auth.split(" ", 1)[1].strip()
return hmac.compare_digest(supplied, expected)
def _session_hash(raw: str) -> str:
return hashlib.sha256(str(raw or "").encode("utf-8")).hexdigest()
@@ -424,6 +453,7 @@ def create_app(
*,
service: LicenseService | None = None,
admin_token: str | None = None,
external_api_token: str | None = None,
) -> FastAPI:
docs_enabled = _env_bool("DYGJ_LICENSE_ENABLE_DOCS", default=False)
app = FastAPI(
@@ -434,6 +464,9 @@ def create_app(
)
app.state.license_service = service
app.state.admin_token = admin_token if admin_token is not None else admin_token_from_env()
app.state.external_api_token = (
external_api_token if external_api_token is not None else external_api_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 = {}
@@ -476,6 +509,113 @@ def create_app(
return result_response(LicenseActionResult(False, "rate_limited", "请求过于频繁,请稍后再试"))
return result_response(get_service().verify_license_doc(req.license))
@app.post("/api/v1/redeem/external/create")
def redeem_external_create(request: Request, req: CreateRedeemRequest) -> JSONResponse:
if not _bearer_token_allowed(request, app.state.external_api_token):
return JSONResponse(
{"ok": False, "reason": "forbidden", "message": "外部接口 token 无效"},
status_code=403,
)
if _rate_limited(request, "redeem_create"):
return JSONResponse(
{"ok": False, "reason": "rate_limited", "message": "请求过于频繁,请稍后再试"},
status_code=429,
)
try:
token = get_service().create_redeem_token(
days=req.days,
max_devices=req.max_devices,
customer=req.customer,
platform=req.platform,
external_order_id=req.external_order_id,
expires_hours=req.expires_hours,
)
except ValueError as exc:
return JSONResponse(
{"ok": False, "reason": "invalid_params", "message": str(exc)},
status_code=400,
)
claim_path = f"/redeem/{token.token}"
claim_url = urljoin(_public_base_url(request) + "/", claim_path.lstrip("/"))
return JSONResponse(
{
"ok": True,
"reason": "ok",
"claim_url": claim_url,
"token_hint": token.token_hint,
"expires_at": token.expires_at.isoformat().replace("+00:00", "Z"),
}
)
@app.post("/api/v1/redeem/claim")
def redeem_claim(req: ClaimRedeemRequest) -> JSONResponse:
result = get_service().claim_redeem_token(req.token)
if result.ok and result.card is not None:
return JSONResponse(
{
"ok": True,
"reason": "ok",
"message": result.message,
"card_key": result.card.code,
"days": result.card.days,
"max_devices": result.card.max_devices,
}
)
status = 409 if result.reason == "already_redeemed" else _status_for_reason(result.reason)
return JSONResponse(
{"ok": False, "reason": result.reason, "message": result.message},
status_code=status,
)
@app.get("/redeem/{token}")
def redeem_page(token: str) -> HTMLResponse:
raw_token = str(token or "")
safe_token = escape(str(token or ""), quote=True)
script_token = json.dumps(raw_token)
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: linear-gradient(135deg, #0f172a, #1e293b); color: #0f172a; }}
main {{ width: min(520px, calc(100vw - 32px)); background: #fff; border-radius: 24px; padding: 28px; box-shadow: 0 28px 80px rgba(0, 0, 0, .35); }}
h1 {{ margin: 0 0 8px; font-size: 28px; }}
p {{ color: #64748b; line-height: 1.7; }}
code {{ display: block; word-break: break-all; background: #f1f5f9; padding: 12px; border-radius: 12px; }}
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; }}
#result {{ margin-top: 14px; padding: 12px; border-radius: 12px; background: #f8fafc; min-height: 24px; }}
</style>
</head>
<body>
<main>
<h1>兑换软件授权</h1>
<p>点击兑换后会生成正式卡密。卡密只显示一次,请妥善保存。</p>
<code>{safe_token}</code>
<button id="claim">立即兑换</button>
<div id="result"></div>
</main>
<script>
document.getElementById("claim").addEventListener("click", async () => {{
const result = document.getElementById("result");
result.textContent = "正在兑换...";
const resp = await fetch("/api/v1/redeem/claim", {{
method: "POST",
headers: {{ "content-type": "application/json" }},
body: JSON.stringify({{ token: {script_token} }})
}});
const data = await resp.json();
if (data.ok) {{
result.innerHTML = "兑换成功,卡密:<code>" + data.card_key + "</code>";
}} else {{
result.textContent = data.message || data.reason || "兑换失败";
}}
}});
</script>
</body>
</html>"""
return HTMLResponse(html)
@app.get("/api/v1/update/manifest")
def update_manifest(request: Request) -> JSONResponse:
return JSONResponse(_signed_update_manifest(get_service(), request))
+183 -18
View File
@@ -19,6 +19,9 @@ MAX_CARD_DAYS = 3660
MAX_CREATE_COUNT = 100
MAX_CARD_DEVICES = 20
MAX_CUSTOMER_LENGTH = 120
MAX_REDEEM_EXPIRES_HOURS = 24 * 30
MAX_PLATFORM_LENGTH = 40
MAX_EXTERNAL_ORDER_LENGTH = 120
@dataclass(frozen=True)
@@ -29,6 +32,27 @@ class CreatedCard:
customer: str
@dataclass(frozen=True)
class CreatedRedeemToken:
token: str
token_hint: str
days: int
max_devices: int
customer: str
platform: str
external_order_id: str
expires_at: datetime
@dataclass(frozen=True)
class RedeemClaimResult:
ok: bool
reason: str
message: str
card: CreatedCard | None = None
expires_at: datetime | None = None
@dataclass(frozen=True)
class LicenseActionResult:
ok: bool
@@ -130,6 +154,14 @@ def generate_card_code() -> str:
return f"DG-{groups}"
def generate_redeem_token() -> str:
return secrets.token_urlsafe(32)
def hash_redeem_token(token: str) -> str:
return hashlib.sha256(str(token or "").strip().encode("utf-8")).hexdigest()
def sanitize_update_filename(filename: str, *, version: str = "") -> str:
raw = Path(str(filename or "")).name.strip()
if not raw.lower().endswith(".exe"):
@@ -217,6 +249,23 @@ class LicenseService:
reason TEXT NOT NULL DEFAULT '',
created_at TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS redeem_tokens (
id INTEGER PRIMARY KEY AUTOINCREMENT,
token_hash TEXT NOT NULL UNIQUE,
token_hint TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'pending',
days INTEGER NOT NULL,
max_devices INTEGER NOT NULL DEFAULT 1,
customer TEXT NOT NULL DEFAULT '',
platform TEXT NOT NULL DEFAULT '',
external_order_id TEXT NOT NULL DEFAULT '',
created_at TEXT NOT NULL,
expires_at TEXT NOT NULL,
redeemed_at TEXT,
license_id INTEGER,
FOREIGN KEY(license_id) REFERENCES license_keys(id)
);
"""
)
@@ -235,31 +284,115 @@ class LicenseService:
cards: list[CreatedCard] = []
with self._connect() as conn:
for _ in range(count):
code = generate_card_code()
card = CreatedCard(
code=code,
card, _license_id = self._insert_card(
conn,
days=days,
max_devices=max_devices,
customer=customer,
)
conn.execute(
"""
INSERT INTO license_keys
(code_hash, code_hint, status, days, max_devices, customer, created_at)
VALUES (?, ?, 'active', ?, ?, ?, ?)
""",
(
hash_card_code(code),
mask_card_code(code),
days,
max_devices,
card.customer,
iso_utc(utcnow()),
),
)
cards.append(card)
return cards
def create_redeem_token(
self,
*,
days: int,
max_devices: int = 1,
customer: str = "",
platform: str = "",
external_order_id: str = "",
expires_hours: int = 72,
) -> CreatedRedeemToken:
days = _bounded_int(days, name="days", minimum=1, maximum=MAX_CARD_DAYS)
max_devices = _bounded_int(max_devices, name="max_devices", minimum=1, maximum=MAX_CARD_DEVICES)
expires_hours = _bounded_int(
expires_hours,
name="expires_hours",
minimum=1,
maximum=MAX_REDEEM_EXPIRES_HOURS,
)
customer = str(customer or "").strip()[:MAX_CUSTOMER_LENGTH]
platform = str(platform or "").strip()[:MAX_PLATFORM_LENGTH]
external_order_id = str(external_order_id or "").strip()[:MAX_EXTERNAL_ORDER_LENGTH]
token = generate_redeem_token()
token_hint = mask_card_code(token)
expires_at = utcnow() + timedelta(hours=expires_hours)
with self._connect() as conn:
conn.execute(
"""
INSERT INTO redeem_tokens
(token_hash, token_hint, status, days, max_devices, customer, platform,
external_order_id, created_at, expires_at)
VALUES (?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?)
""",
(
hash_redeem_token(token),
token_hint,
days,
max_devices,
customer,
platform,
external_order_id,
iso_utc(utcnow()),
iso_utc(expires_at),
),
)
self._audit(conn, "redeem_create", token, "", "ok")
return CreatedRedeemToken(
token=token,
token_hint=token_hint,
days=days,
max_devices=max_devices,
customer=customer,
platform=platform,
external_order_id=external_order_id,
expires_at=expires_at,
)
def claim_redeem_token(self, token: str) -> RedeemClaimResult:
raw_token = str(token or "").strip()
if not raw_token:
return RedeemClaimResult(False, "missing_token", "缺少兑换码")
with self._connect() as conn:
row = conn.execute(
"SELECT * FROM redeem_tokens WHERE token_hash = ?",
(hash_redeem_token(raw_token),),
).fetchone()
if row is None:
self._audit(conn, "redeem_claim", raw_token, "", "not_found")
return RedeemClaimResult(False, "not_found", "兑换链接不存在")
status = str(row["status"] or "").strip().lower()
if status == "redeemed":
self._audit(conn, "redeem_claim", raw_token, "", "already_redeemed")
return RedeemClaimResult(False, "already_redeemed", "兑换链接已使用")
if status != "pending":
self._audit(conn, "redeem_claim", raw_token, "", status or "inactive")
return RedeemClaimResult(False, status or "inactive", "兑换链接不可用")
expires_at = parse_utc(row["expires_at"])
if utcnow() > expires_at:
conn.execute(
"UPDATE redeem_tokens SET status = 'expired' WHERE id = ?",
(row["id"],),
)
self._audit(conn, "redeem_claim", raw_token, "", "expired")
return RedeemClaimResult(False, "expired", "兑换链接已过期", expires_at=expires_at)
card, license_id = self._insert_card(
conn,
days=int(row["days"]),
max_devices=int(row["max_devices"]),
customer=str(row["customer"] or ""),
)
conn.execute(
"""
UPDATE redeem_tokens
SET status = 'redeemed', redeemed_at = ?, license_id = ?
WHERE id = ?
""",
(iso_utc(utcnow()), license_id, row["id"]),
)
self._audit(conn, "redeem_claim", raw_token, "", "ok")
return RedeemClaimResult(True, "ok", "兑换成功", card=card, expires_at=expires_at)
def revoke(self, code: str) -> bool:
with self._connect() as conn:
cur = conn.execute(
@@ -605,6 +738,38 @@ class LicenseService:
(str(code_hash or "").strip().lower(),),
).fetchone()
def _insert_card(
self,
conn: sqlite3.Connection,
*,
days: int,
max_devices: int,
customer: str,
) -> tuple[CreatedCard, int]:
code = generate_card_code()
card = CreatedCard(
code=code,
days=int(days),
max_devices=int(max_devices),
customer=str(customer or "").strip()[:MAX_CUSTOMER_LENGTH],
)
cur = conn.execute(
"""
INSERT INTO license_keys
(code_hash, code_hint, status, days, max_devices, customer, created_at)
VALUES (?, ?, 'active', ?, ?, ?, ?)
""",
(
hash_card_code(code),
mask_card_code(code),
card.days,
card.max_devices,
card.customer,
iso_utc(utcnow()),
),
)
return card, int(cur.lastrowid)
def _invalid_card_reason(self, card: sqlite3.Row) -> str:
status = str(card["status"] or "").strip().lower()
if status == "revoked":
+88
View File
@@ -373,3 +373,91 @@ def test_api_rate_limits_repeated_failed_activation(tmp_path, monkeypatch):
assert limited.status_code == 429
assert limited.json()["reason"] == "rate_limited"
def test_external_redeem_create_requires_bearer_token(tmp_path):
from fastapi.testclient import TestClient
from license_server import api
from license_server.core import LicenseService
from tests.license_test_keys import TEST_PRIVATE_KEY_PEM
service = LicenseService(db_path=tmp_path / "license.db", private_key_pem=TEST_PRIVATE_KEY_PEM)
client = TestClient(
api.create_app(service=service, external_api_token="external-secret"),
base_url="https://dy.absfan.cn",
)
resp = client.post(
"/api/v1/redeem/external/create",
json={
"platform": "xianyu",
"external_order_id": "ORDER-1",
"customer": "buyer-a",
"days": 30,
"max_devices": 1,
},
)
assert resp.status_code == 403
assert resp.json()["reason"] == "forbidden"
def test_external_redeem_create_returns_claim_url_without_card_key(tmp_path):
from fastapi.testclient import TestClient
from license_server import api
from license_server.core import LicenseService
from tests.license_test_keys import TEST_PRIVATE_KEY_PEM
service = LicenseService(db_path=tmp_path / "license.db", private_key_pem=TEST_PRIVATE_KEY_PEM)
client = TestClient(
api.create_app(service=service, external_api_token="external-secret"),
base_url="https://dy.absfan.cn",
)
resp = client.post(
"/api/v1/redeem/external/create",
headers={"authorization": "Bearer external-secret"},
json={
"platform": "xianyu",
"external_order_id": "ORDER-1",
"customer": "buyer-a",
"days": 30,
"max_devices": 1,
},
)
body = resp.json()
assert resp.status_code == 200
assert body["ok"] is True
assert body["claim_url"].startswith("https://dy.absfan.cn/redeem/")
assert "card_key" not in body
assert service.stats()["total"] == 0
def test_redeem_claim_exchanges_token_for_card_once(tmp_path):
from fastapi.testclient import TestClient
from license_server import api
from license_server.core import LicenseService
from tests.license_test_keys import TEST_PRIVATE_KEY_PEM
service = LicenseService(db_path=tmp_path / "license.db", private_key_pem=TEST_PRIVATE_KEY_PEM)
token = service.create_redeem_token(
days=30,
max_devices=1,
customer="buyer-a",
platform="xianyu",
external_order_id="ORDER-1",
)
client = TestClient(api.create_app(service=service), base_url="https://dy.absfan.cn")
first = client.post("/api/v1/redeem/claim", json={"token": token.token})
second = client.post("/api/v1/redeem/claim", json={"token": token.token})
assert first.status_code == 200
assert first.json()["ok"] is True
assert first.json()["card_key"].startswith("DG-")
assert second.status_code == 409
assert second.json()["reason"] == "already_redeemed"
+55
View File
@@ -100,3 +100,58 @@ def test_license_server_verify_license_doc_requires_card_hash(tmp_path):
assert result.ok is False
assert result.reason == "invalid_signature"
def test_license_server_redeem_token_creates_card_only_when_claimed(tmp_path):
from license_server import core
from tests.license_test_keys import TEST_PRIVATE_KEY_PEM
service = core.LicenseService(db_path=tmp_path / "license.db", private_key_pem=TEST_PRIVATE_KEY_PEM)
token = service.create_redeem_token(
days=14,
max_devices=2,
customer="xianyu-order-1",
platform="xianyu",
external_order_id="ORDER-1",
)
before = service.stats()
claimed = service.claim_redeem_token(token.token)
second = service.claim_redeem_token(token.token)
assert before["total"] == 0
assert claimed.ok is True
assert claimed.card is not None
assert claimed.card.code.startswith("DG-")
assert claimed.card.days == 14
assert claimed.card.max_devices == 2
assert claimed.card.customer == "xianyu-order-1"
assert second.ok is False
assert second.reason == "already_redeemed"
assert service.stats()["total"] == 1
def test_license_server_redeem_token_rejects_expired_token(tmp_path, monkeypatch):
from datetime import timedelta
from license_server import core
from tests.license_test_keys import TEST_PRIVATE_KEY_PEM
service = core.LicenseService(db_path=tmp_path / "license.db", private_key_pem=TEST_PRIVATE_KEY_PEM)
start = core.utcnow()
monkeypatch.setattr(core, "utcnow", lambda: start)
token = service.create_redeem_token(
days=7,
max_devices=1,
customer="expired-order",
platform="xianyu",
external_order_id="ORDER-EXPIRED",
expires_hours=1,
)
monkeypatch.setattr(core, "utcnow", lambda: start + timedelta(hours=2))
result = service.claim_redeem_token(token.token)
assert result.ok is False
assert result.reason == "expired"
assert service.stats()["total"] == 0