feat(auth): 新增手机号与 DCAuth 设备认证登录

- 登录链路改为用户名 + 密码 + 短信验证码 + DCAuth v2 设备签名
- 新增 login_sms_codes / user_devices / device_challenges 三张表,迁移 0063/0064
- 设备绑定只比对 deviceId + publicKey,每账号一个 active 设备,管理员可重置
- 保留未绑定手机号账号的密码登录兜底,绑定后强制安全登录
- 登录页与用户管理页支持验证码、DCAuth 轮询、手机号绑定与设备重置
This commit is contained in:
yml2213
2026-10-21 22:00:03 +08:00
parent f21362dfe3
commit 2f5a63ae27
24 changed files with 3049 additions and 130 deletions
+123
View File
@@ -0,0 +1,123 @@
"""管理端账号安全设置:绑定手机号、重置绑定设备。"""
from __future__ import annotations
from datetime import UTC, datetime
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from ..database import get_db
from ..deps import require_permission
from ..errors import ApiError
from ..models import AuditLog, User, UserDevice
from ..schemas import UserInfo, UserPhoneBindRequest
from ..services.dc_auth_service import mask_device_id
from ..services.login_sms_service import mask_phone, normalize_phone
from ..services.user_profile_service import to_user_info
router = APIRouter(prefix="/api/admin/users", tags=["用户管理"])
def _get_user(db: Session, user_id: int) -> User:
user = db.query(User).filter(User.id == user_id, User.deleted_at.is_(None)).first()
if user is None:
raise HTTPException(status_code=404, detail="用户不存在")
return user
def _active_device(db: Session, user_id: int) -> UserDevice | None:
return (
db.query(UserDevice)
.filter(UserDevice.user_id == user_id, UserDevice.status == "active")
.order_by(UserDevice.id.desc())
.first()
)
@router.post("/{user_id}/phone", response_model=UserInfo)
def bind_user_phone(
user_id: int,
req: UserPhoneBindRequest,
db: Session = Depends(get_db),
current: User = Depends(require_permission("user:edit")),
):
user = _get_user(db, user_id)
phone = normalize_phone(req.phone)
if not phone:
raise ApiError(400, "请输入手机号", "phone_required")
existing = db.query(User).filter(User.phone == phone, User.id != user.id).first()
if existing is not None:
raise ApiError(409, "该手机号已绑定其他用户", "phone_exists")
now = datetime.now(UTC)
user.phone = phone
user.phone_bound_at = now
user.phone_bound_by = current.id
db.add(
AuditLog(
user_id=current.id,
username=current.username,
action="user:phone_bind",
target=user.username,
detail=f"phone={mask_phone(phone)}",
)
)
try:
db.commit()
except IntegrityError as exc:
db.rollback()
raise ApiError(409, "该手机号已绑定其他用户", "phone_exists") from exc
db.refresh(user)
return to_user_info(user, _active_device(db, user.id))
@router.post("/{user_id}/device/reset")
def reset_user_device(
user_id: int,
db: Session = Depends(get_db),
current: User = Depends(require_permission("user:edit")),
):
user = _get_user(db, user_id)
now = datetime.now(UTC)
active = _active_device(db, user.id)
revoked = (
db.query(UserDevice)
.filter(UserDevice.user_id == user.id, UserDevice.status == "active")
.update(
{
UserDevice.status: "revoked",
UserDevice.revoked_at: now,
UserDevice.revoked_by: current.id,
UserDevice.updated_at: now,
},
synchronize_session=False,
)
)
db.add(
AuditLog(
user_id=current.id,
username=current.username,
action="user:device_reset",
target=user.username,
detail=(
f"revoked={revoked}; device={mask_device_id(active.device_id)}"
if active is not None
else "revoked=0"
),
)
)
db.commit()
return {
"success": True,
"reset": revoked > 0,
"revoked": revoked,
"message": "已重置设备,下次登录将重新绑定"
if revoked
else "当前没有已绑定设备",
}
+196 -17
View File
@@ -1,16 +1,42 @@
"""认证路由"""
"""认证路由:安全登录(短信 + DCAuth v2)与旧账号密码兜底。"""
from __future__ import annotations
import os
from fastapi import APIRouter, Depends, HTTPException, Response
from fastapi import APIRouter, Depends, Request, Response
from sqlalchemy.orm import Session
from ..database import get_db
from ..deps import get_current_user
from ..models import AuditLog, User
from ..errors import ApiError
from ..models import AuditLog, DeviceChallenge, User
from ..permissions import ROLE_LABELS, get_user_permissions
from ..schemas import LoginRequest, TokenResponse
from ..schemas import (
LoginCompleteRequest,
LoginPrepareRequest,
LoginPrepareResponse,
LoginRequest,
SmsCodeRequest,
SmsCodeResponse,
TokenResponse,
)
from ..security import ACCESS_TOKEN_EXPIRE_HOURS, create_access_token, verify_password
from ..services.dc_auth_service import (
APP_ID,
CHALLENGE_PURPOSE,
consume_device_ticket,
create_login_challenge,
ensure_device_binding,
get_challenge,
mask_device_id,
normalize_api_base,
)
from ..services.login_sms_service import (
mask_phone,
send_login_sms_code,
verify_login_sms_code,
)
router = APIRouter(prefix="/api/auth", tags=["认证"])
@@ -18,18 +44,38 @@ router = APIRouter(prefix="/api/auth", tags=["认证"])
_COOKIE_SECURE = os.getenv("COOKIE_SECURE", "false").lower() == "true"
@router.post("/login", response_model=TokenResponse)
def login(req: LoginRequest, response: Response, db: Session = Depends(get_db)):
user = db.query(User).filter(User.username == req.username).first()
if not user or not verify_password(req.password, user.password_hash):
raise HTTPException(status_code=401, detail="用户名或密码错误")
if not user.is_active:
raise HTTPException(status_code=403, detail="账号已禁用,请联系管理员")
def _find_user(db: Session, username_value: str) -> User | None:
"""用户名只 trim,不做大小写折叠、不限制字符集。
token = create_access_token({"sub": str(user.id), "role": user.role})
perms = get_user_permissions(user)
MySQL 默认排序规则大小写不敏感,因此查出来后还要做一次 Python 侧精确比对,
避免 ``Admin`` 命中 ``admin``。
"""
username = str(username_value or "").strip()
if not username:
return None
user = db.query(User).filter(User.username == username).first()
if user is not None and user.username != username:
return None
return user
# 设置 httpOnly cookie(前端无需 JS 读取 token,防 XSS 窃取)
def _authenticate(db: Session, username: str, password: str) -> User:
user = _find_user(db, username)
if user is None or not verify_password(password, user.password_hash):
raise ApiError(401, "用户名或密码错误", "invalid_credentials")
if not user.is_active or user.deleted_at is not None:
raise ApiError(403, "账号已禁用,请联系管理员", "user_disabled")
return user
def _request_origin(request: Request) -> str:
origin = str(request.headers.get("origin") or "").strip()
if origin:
return origin
return str(request.base_url).rstrip("/")
def _set_auth_cookie(response: Response, token: str) -> None:
response.set_cookie(
key="access_token",
value=token,
@@ -40,9 +86,28 @@ def login(req: LoginRequest, response: Response, db: Session = Depends(get_db)):
path="/",
)
# 审计
def _issue_session(
db: Session,
response: Response,
user: User,
method: str,
device_id: str = "",
) -> TokenResponse:
token = create_access_token({"sub": str(user.id), "role": user.role})
_set_auth_cookie(response, token)
detail = f"method={method}"
if device_id:
detail += f"; device={mask_device_id(device_id)}"
db.add(
AuditLog(user_id=user.id, username=user.username, action="login", target="auth")
AuditLog(
user_id=user.id,
username=user.username,
action="login",
target="auth",
detail=detail,
)
)
db.commit()
@@ -50,10 +115,122 @@ def login(req: LoginRequest, response: Response, db: Session = Depends(get_db)):
access_token=token,
role=user.role,
username=user.username,
permissions=perms,
permissions=get_user_permissions(user),
)
def _require_phone(user: User) -> str:
phone = str(user.phone or "").strip()
if not phone:
raise ApiError(
409,
"该账号尚未绑定手机号,请联系管理员",
"phone_unbound",
)
return phone
@router.post("/sms-code", response_model=SmsCodeResponse)
def send_sms_code(
req: SmsCodeRequest,
request: Request,
db: Session = Depends(get_db),
):
user = _authenticate(db, req.username, req.password)
phone = _require_phone(user)
request_ip = request.client.host if request.client else ""
result = send_login_sms_code(db, user, phone, request_ip=request_ip)
return SmsCodeResponse(
sent=True,
phone_masked=result["phoneMasked"],
expires_in_seconds=result["expiresInSeconds"],
provider=result["provider"],
)
@router.post("/prepare", response_model=LoginPrepareResponse)
def prepare_login(
req: LoginPrepareRequest,
request: Request,
db: Session = Depends(get_db),
):
user = _authenticate(db, req.username, req.password)
phone = _require_phone(user)
# 先校验并消费短信码,再创建 challenge(与参考实现一致)。
verify_login_sms_code(db, user.id, req.sms_code)
api_base = normalize_api_base(req.api_base or _request_origin(request))
challenge = create_login_challenge(db, user.id, api_base)
return LoginPrepareResponse(
challenge_id=challenge["challengeId"],
challenge=challenge["challenge"],
expires_at=challenge["expiresAt"],
poll_token=challenge["pollToken"],
launch_url=challenge["launchUrl"],
phone_masked=mask_phone(phone),
app=challenge["app"],
)
@router.post("/complete", response_model=TokenResponse)
def complete_login(
req: LoginCompleteRequest,
response: Response,
db: Session = Depends(get_db),
):
challenge = get_challenge(db, req.challenge_id)
if (
challenge is None
or challenge.user_id is None
or challenge.app != APP_ID
or challenge.purpose != CHALLENGE_PURPOSE
):
raise ApiError(
404,
"设备认证会话不存在,请重新登录",
"challenge_not_found",
)
user = (
db.query(User)
.filter(User.id == challenge.user_id, User.deleted_at.is_(None))
.first()
)
if user is None or not user.is_active:
raise ApiError(401, "账号已不可用,请重新登录", "user_disabled")
consumed: DeviceChallenge = consume_device_ticket(
db,
req.challenge_id,
req.poll_token,
req.device_ticket,
)
if consumed.user_id != user.id:
raise ApiError(401, "设备认证票据无效", "ticket_invalid")
ensure_device_binding(db, user, consumed)
return _issue_session(db, response, user, "sms_device", consumed.device_id)
@router.post("/login", response_model=TokenResponse)
def login(
req: LoginRequest,
response: Response,
db: Session = Depends(get_db),
):
"""旧账号兜底:仅当用户未绑定手机号时允许密码单因素登录。"""
user = _authenticate(db, req.username, req.password)
if str(user.phone or "").strip():
raise ApiError(
403,
"该账号已启用安全登录,请使用用户名 + 密码 + 短信验证码 + 本机验证",
"secure_login_required",
)
return _issue_session(db, response, user, "password_legacy")
@router.get("/me")
def me(current_user: User = Depends(get_current_user)):
return {
@@ -64,6 +241,8 @@ def me(current_user: User = Depends(get_current_user)):
"is_active": current_user.is_active,
"remark": current_user.remark,
"permissions": get_user_permissions(current_user),
"phone_masked": mask_phone(current_user.phone),
"phone_bound": bool(str(current_user.phone or "").strip()),
}
+39
View File
@@ -0,0 +1,39 @@
"""DCAuth v2 客户端协议入口。
客户端(DCAuth.exe / dcauth)把 authorize 路径硬编码为
``POST {apiBase}/api/dcauth/authorize``,因此这里的路径不能改。
"""
from __future__ import annotations
from fastapi import APIRouter, Depends, Header, Query
from sqlalchemy.orm import Session
from ..database import get_db
from ..schemas import DeviceAuthorizeRequest
from ..services.dc_auth_service import (
authorize_device,
get_challenge_status,
)
router = APIRouter(prefix="/api/dcauth", tags=["设备认证"])
@router.post("/authorize")
def authorize(
payload: DeviceAuthorizeRequest,
db: Session = Depends(get_db),
):
result = authorize_device(db, payload.model_dump(by_alias=True))
return {"success": True, **result}
@router.get("/challenge/{challenge_id}/status")
def challenge_status(
challenge_id: str,
poll_token: str | None = Query(None, alias="pollToken"),
header_poll_token: str | None = Header(None, alias="X-Poll-Token"),
db: Session = Depends(get_db),
):
token = header_poll_token or poll_token or ""
return get_challenge_status(db, challenge_id, token)
+28 -51
View File
@@ -9,35 +9,44 @@ from sqlalchemy.orm import Session
from ..database import get_db
from ..deps import require_permission
from ..models import Account, AuditLog, HuyaAccount, User
from ..permissions import PERMISSIONS, get_user_permissions
from ..models import Account, AuditLog, HuyaAccount, User, UserDevice
from ..permissions import PERMISSIONS
from ..schemas import UserCreate, UserInfo, UserRename, UserUpdate
from ..security import hash_password
from ..services.user_profile_service import to_user_info
router = APIRouter(prefix="/api/users", tags=["用户管理"])
def _active_device(db: Session, user_id: int) -> UserDevice | None:
return (
db.query(UserDevice)
.filter(UserDevice.user_id == user_id, UserDevice.status == "active")
.order_by(UserDevice.id.desc())
.first()
)
@router.get("", response_model=list[UserInfo])
def list_users(
db: Session = Depends(get_db),
_: User = Depends(require_permission("user:view")),
):
users = db.query(User).filter(User.deleted_at.is_(None)).order_by(User.id).all()
result = []
for u in users:
result.append(
UserInfo(
id=u.id,
username=u.username,
role=u.role,
is_active=u.is_active,
remark=u.remark or "",
created_at=u.created_at,
permissions=get_user_permissions(u),
custom_permissions=u.custom_permissions,
devices: dict[int, UserDevice] = {}
if users:
device_rows = (
db.query(UserDevice)
.filter(
UserDevice.user_id.in_([user.id for user in users]),
UserDevice.status == "active",
)
.order_by(UserDevice.id.desc())
.all()
)
return result
for device in device_rows:
devices.setdefault(device.user_id, device)
return [to_user_info(user, devices.get(user.id)) for user in users]
@router.post("", response_model=UserInfo)
@@ -70,15 +79,7 @@ def create_user(
)
db.commit()
return UserInfo(
id=user.id,
username=user.username,
role=user.role,
is_active=user.is_active,
remark=user.remark or "",
permissions=get_user_permissions(user),
custom_permissions=user.custom_permissions,
)
return to_user_info(user, _active_device(db, user.id))
@router.put("/{user_id}", response_model=UserInfo)
@@ -118,15 +119,7 @@ def update_user(
)
db.commit()
return UserInfo(
id=user.id,
username=user.username,
role=user.role,
is_active=user.is_active,
remark=user.remark or "",
permissions=get_user_permissions(user),
custom_permissions=user.custom_permissions,
)
return to_user_info(user, _active_device(db, user.id))
@router.patch("/{user_id}/username", response_model=UserInfo)
@@ -145,15 +138,7 @@ def rename_user(
if len(username) < 2:
raise HTTPException(status_code=400, detail="用户名至少 2 个字符")
if username == user.username:
return UserInfo(
id=user.id,
username=user.username,
role=user.role,
is_active=user.is_active,
remark=user.remark or "",
permissions=get_user_permissions(user),
custom_permissions=user.custom_permissions,
)
return to_user_info(user, _active_device(db, user.id))
if db.query(User.id).filter(User.username == username).first():
raise HTTPException(status_code=400, detail="用户名已存在")
@@ -173,15 +158,7 @@ def rename_user(
db.rollback()
raise HTTPException(status_code=400, detail="用户名已存在") from exc
db.refresh(user)
return UserInfo(
id=user.id,
username=user.username,
role=user.role,
is_active=user.is_active,
remark=user.remark or "",
permissions=get_user_permissions(user),
custom_permissions=user.custom_permissions,
)
return to_user_info(user, _active_device(db, user.id))
@router.delete("/{user_id}")