319 lines
13 KiB
Python
319 lines
13 KiB
Python
"""登录与权限(RBAC)。
|
||
|
||
三层模型:**用户 ←(多对多)→ 角色 ←(一对多)→ 菜单授权**
|
||
· `role_menus` 存授权矩阵:一行 = 一个菜单一个级别,`rw` 可编辑 / `ro` 只读,
|
||
表里没有这一行就是看不到该菜单;
|
||
· 一个用户可以挂多个角色,最终权限取并集(同一菜单取更高级别);
|
||
· 菜单权限同时管两端:前端按 `/auth/me` 返回的 menus 过滤侧栏与写操作按钮,
|
||
后端 `guard` 按「请求路径 → 菜单 → 级别」二次校验,直接调接口也绕不过去;
|
||
· 所有写操作与登录行为写进 `audit_logs`,在「权限管理 → 操作日志」里查。
|
||
|
||
会话是服务端 token(HttpOnly Cookie),退出登录 / 停用 / 改密 / 强制下线都是删 token,立即失效。
|
||
密码只存 pbkdf2 派生值,用标准库,不引额外依赖。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import hashlib
|
||
import hmac
|
||
import json
|
||
import secrets
|
||
from datetime import datetime, timedelta
|
||
|
||
from fastapi import Depends, HTTPException, Request
|
||
from sqlalchemy import inspect, text
|
||
from sqlalchemy.orm import Session
|
||
|
||
from . import config
|
||
from .constants import (
|
||
LEVEL_LABELS,
|
||
LEVEL_RANK,
|
||
LEVELS,
|
||
MENUS,
|
||
MENU_KEYS,
|
||
MENU_LABELS,
|
||
merge_levels,
|
||
)
|
||
from .db import get_db
|
||
from .models import Role, RoleMenu, User, UserRole, UserSession, now
|
||
|
||
SESSION_COOKIE = "unis_session"
|
||
PBKDF2_ROUNDS = 120_000
|
||
|
||
__all__ = [
|
||
"MENUS", "MENU_KEYS", "MENU_LABELS", "LEVELS", "LEVEL_LABELS",
|
||
"SESSION_COOKIE", "normalize_menus", "menus_json", "hash_password", "verify_password",
|
||
"start_session", "revoke_all", "user_from_token", "current_user", "guard",
|
||
"resolve_rule", "ensure_seed", "migrate_legacy_rbac", "level_of",
|
||
]
|
||
|
||
# 接口路径首段 -> 菜单。没列出来的(/meta 等)只要求登录,不看菜单。
|
||
SEGMENT_MENU = {
|
||
"focus": "focus",
|
||
"weekly": "board",
|
||
"projects": "projects",
|
||
"categories": "projects",
|
||
"updates": "projects",
|
||
"custom": "custom",
|
||
"staff": "staff",
|
||
"ai": "intake",
|
||
"settings": "settings",
|
||
"rbac": "rbac",
|
||
"periods": "settings",
|
||
}
|
||
# /export/xxx 跟着对应页面走
|
||
EXPORT_MENU = {
|
||
"custom": "custom",
|
||
"custom-updates": "custom",
|
||
"projects": "projects",
|
||
"updates": "projects",
|
||
"staff": "staff",
|
||
"focus": "focus",
|
||
}
|
||
|
||
|
||
# ------------------------------------------------------------------ 权限表
|
||
def normalize_menus(raw) -> dict:
|
||
"""清洗前端传来的权限表:只留已知菜单 + 合法级别。"""
|
||
out: dict[str, str] = {}
|
||
for key, value in (raw or {}).items():
|
||
if key in MENU_LABELS and value in LEVELS:
|
||
out[key] = value
|
||
return out
|
||
|
||
|
||
def menus_json(menus: dict) -> str:
|
||
return json.dumps(normalize_menus(menus), ensure_ascii=False, sort_keys=True)
|
||
|
||
|
||
def level_of(user: User | None, menu: str) -> str:
|
||
if user is None:
|
||
return ""
|
||
return user.menus.get(menu, "")
|
||
|
||
|
||
# ------------------------------------------------------------------ 密码
|
||
def hash_password(password: str) -> tuple[str, str]:
|
||
salt = secrets.token_hex(16)
|
||
digest = hashlib.pbkdf2_hmac("sha256", password.encode(), bytes.fromhex(salt), PBKDF2_ROUNDS)
|
||
return digest.hex(), salt
|
||
|
||
|
||
def verify_password(password: str, password_hash: str, salt: str) -> bool:
|
||
try:
|
||
digest = hashlib.pbkdf2_hmac(
|
||
"sha256", (password or "").encode(), bytes.fromhex(salt), PBKDF2_ROUNDS
|
||
)
|
||
except ValueError:
|
||
return False
|
||
return hmac.compare_digest(digest.hex(), password_hash)
|
||
|
||
|
||
# ------------------------------------------------------------------ 会话
|
||
def _clip(value: str | None, size: int) -> str | None:
|
||
return value[:size] if value else None
|
||
|
||
|
||
def start_session(db: Session, user: User, ip: str | None = None,
|
||
user_agent: str | None = None) -> str:
|
||
token = secrets.token_urlsafe(32)
|
||
db.add(UserSession(token=token, user_id=user.id,
|
||
expires_at=now() + timedelta(days=config.SESSION_DAYS),
|
||
ip=_clip(ip, 64), user_agent=_clip(user_agent, 128)))
|
||
user.last_login_at = now()
|
||
db.commit()
|
||
return token
|
||
|
||
|
||
def revoke_all(db: Session, user_id: int, keep_token: str | None = None) -> None:
|
||
q = db.query(UserSession).filter(UserSession.user_id == user_id)
|
||
if keep_token:
|
||
q = q.filter(UserSession.token != keep_token)
|
||
q.delete(synchronize_session=False)
|
||
db.commit()
|
||
|
||
|
||
def purge_expired_sessions(db: Session) -> int:
|
||
q = db.query(UserSession).filter(UserSession.expires_at < now())
|
||
n = q.count()
|
||
if n:
|
||
q.delete(synchronize_session=False)
|
||
db.commit()
|
||
return n
|
||
|
||
|
||
def user_from_token(db: Session, token: str | None) -> User | None:
|
||
if not token:
|
||
return None
|
||
sess = db.get(UserSession, token)
|
||
if sess is None or sess.expires_at < now():
|
||
return None
|
||
user = db.get(User, sess.user_id)
|
||
if user is None or not user.active:
|
||
return None
|
||
return user
|
||
|
||
|
||
# ------------------------------------------------------------------ 旧库升级
|
||
def migrate_legacy_rbac(engine) -> list[str]:
|
||
"""把旧版的 roles.menus(JSON) / users.role_id 迁到 role_menus / user_roles。
|
||
|
||
幂等:目标表里已经有数据就跳过。老库升级后第一次启动自动完成。
|
||
"""
|
||
notes: list[str] = []
|
||
insp = inspect(engine)
|
||
tables = set(insp.get_table_names())
|
||
if "roles" not in tables or "users" not in tables:
|
||
return notes
|
||
with engine.begin() as conn:
|
||
cols = {c["name"] for c in insp.get_columns("roles")}
|
||
if "menus" in cols and "role_menus" in tables:
|
||
filled = conn.execute(text("SELECT COUNT(*) FROM role_menus")).scalar() or 0
|
||
if not filled:
|
||
rows = conn.execute(text("SELECT id, menus FROM roles")).all()
|
||
moved = 0
|
||
for rid, raw in rows:
|
||
if not raw:
|
||
continue
|
||
try:
|
||
data = json.loads(raw)
|
||
except ValueError:
|
||
continue
|
||
for menu, level in normalize_menus(data).items():
|
||
conn.execute(
|
||
text("INSERT INTO role_menus(role_id, menu, level, created_at) "
|
||
"VALUES(:r,:m,:l,:c)"),
|
||
{"r": rid, "m": menu, "l": level, "c": now()},
|
||
)
|
||
moved += 1
|
||
if moved:
|
||
notes.append(f"角色菜单授权已迁到 role_menus({moved} 条)")
|
||
if "role_id" in {c["name"] for c in insp.get_columns("users")} and "user_roles" in tables:
|
||
filled = conn.execute(text("SELECT COUNT(*) FROM user_roles")).scalar() or 0
|
||
if not filled:
|
||
rows = conn.execute(
|
||
text("SELECT id, role_id FROM users WHERE role_id IS NOT NULL")
|
||
).all()
|
||
for uid, rid in rows:
|
||
conn.execute(
|
||
text("INSERT INTO user_roles(user_id, role_id, created_at) VALUES(:u,:r,:c)"),
|
||
{"u": uid, "r": rid, "c": now()},
|
||
)
|
||
if rows:
|
||
notes.append(f"用户角色已迁到 user_roles({len(rows)} 条)")
|
||
return notes
|
||
|
||
|
||
# ------------------------------------------------------------------ 内置数据
|
||
BUILTIN_ROLES = [
|
||
("管理员", "全部菜单可编辑,含设置与权限管理", {k: "rw" for k in MENU_KEYS}, True),
|
||
("部门成员", "业务菜单可编辑,不能改设置与权限",
|
||
{k: "rw" for k in MENU_KEYS if k not in ("settings", "rbac")}, True),
|
||
("只读访客", "只能查看,不能修改任何数据",
|
||
{k: "ro" for k in MENU_KEYS if k != "rbac"}, True),
|
||
]
|
||
|
||
|
||
def ensure_seed(db: Session) -> list[str]:
|
||
"""首次启动(或升级后)补内置角色与管理员账号,返回新建的提示项。"""
|
||
notes: list[str] = []
|
||
for name, desc, menus, builtin in BUILTIN_ROLES:
|
||
role = db.query(Role).filter(Role.name == name).one_or_none()
|
||
if role is None:
|
||
role = Role(name=name, description=desc, is_builtin=builtin)
|
||
db.add(role)
|
||
db.flush()
|
||
notes.append(f"已创建内置角色「{name}」")
|
||
if not db.query(RoleMenu).filter(RoleMenu.role_id == role.id).count():
|
||
for menu, level in normalize_menus(menus).items():
|
||
db.add(RoleMenu(role_id=role.id, menu=menu, level=level))
|
||
admin_role = db.query(Role).filter(Role.name == "管理员").one()
|
||
if not db.query(User).count():
|
||
pw_hash, salt = hash_password(config.ADMIN_PASSWORD)
|
||
user = User(name=config.ADMIN_USERNAME, username=config.ADMIN_USERNAME,
|
||
password_hash=pw_hash, password_salt=salt, active=True)
|
||
db.add(user)
|
||
db.flush()
|
||
db.add(UserRole(user_id=user.id, role_id=admin_role.id))
|
||
notes.append(f"已创建管理员账号 {config.ADMIN_USERNAME}(请尽快在用户设置里改密码)")
|
||
else:
|
||
# 保证系统里至少有一个能管权限的账号,不会出现把自己锁在门外的情况
|
||
guarded = [u for u in db.query(User).filter(User.active.is_(True)).all()
|
||
if u.menus.get("rbac") == "rw"]
|
||
if not guarded:
|
||
first = db.query(User).order_by(User.id).first()
|
||
db.add(UserRole(user_id=first.id, role_id=admin_role.id))
|
||
notes.append(f"已把「管理员」角色补给 {first.username},避免没人能管权限")
|
||
db.commit()
|
||
return notes
|
||
|
||
|
||
# ------------------------------------------------------------------ 依赖
|
||
READ_METHODS = ("GET", "HEAD", "OPTIONS")
|
||
|
||
|
||
def resolve_rule(path: str, method: str):
|
||
"""请求 -> (菜单, 是否写操作);菜单为 None 表示只要登录就能访问。"""
|
||
parts = [x for x in path.split("/") if x] # /api/custom/projects -> [...]
|
||
if len(parts) >= 2 and parts[0] == "api" and parts[1] == "export":
|
||
name = parts[2] if len(parts) > 2 else ""
|
||
menu = EXPORT_MENU.get(name)
|
||
if menu is None:
|
||
# fail-closed:新增 /export/* 必须先在 EXPORT_MENU 登记归属菜单,否则一律 403,
|
||
# 不会出现「忘了挂权限、任何登录用户都能下载」的窗口。
|
||
raise HTTPException(status_code=403, detail=f"导出接口「{name}」未登记权限归属,禁止访问")
|
||
elif len(parts) >= 2 and parts[0] == "api":
|
||
menu = SEGMENT_MENU.get(parts[1])
|
||
else:
|
||
menu = None
|
||
if menu is None:
|
||
return None
|
||
# 周期表:所有页面顶栏都要读,只有新建/删除算设置页的写操作
|
||
if len(parts) >= 2 and parts[1] == "periods" and method in READ_METHODS:
|
||
return None
|
||
return menu, method not in READ_METHODS
|
||
|
||
|
||
def guard(request: Request, db: Session = Depends(get_db)) -> User | None:
|
||
"""挂在 /api 子应用上的总闸:先验登录,再按菜单权限放行。"""
|
||
path = request.url.path
|
||
if path.rstrip("/") == "/api/auth/login":
|
||
return None
|
||
user = user_from_token(db, request.cookies.get(SESSION_COOKIE))
|
||
request.state.user = user
|
||
if user is None:
|
||
raise HTTPException(status_code=401, detail="登录已失效,请重新登录")
|
||
if path.startswith("/api/rbac/"):
|
||
# 权限管理自身必须显式授权,普通用户即使能读别的菜单也不能碰
|
||
if "rbac" not in user.menus:
|
||
raise HTTPException(status_code=403, detail=f"没有「{MENU_LABELS['rbac']}」的访问权限")
|
||
if request.method not in READ_METHODS and user.menus.get("rbac") != "rw":
|
||
raise HTTPException(status_code=403, detail=f"「{MENU_LABELS['rbac']}」是只读权限,不能修改")
|
||
return user
|
||
rule = resolve_rule(path, request.method)
|
||
if rule is None:
|
||
return user
|
||
menu, need_write = rule
|
||
level = user.menus.get(menu)
|
||
if not level:
|
||
raise HTTPException(status_code=403, detail=f"没有「{MENU_LABELS.get(menu, menu)}」的访问权限")
|
||
if need_write and level != "rw":
|
||
raise HTTPException(status_code=403, detail=f"「{MENU_LABELS.get(menu, menu)}」是只读权限,不能修改")
|
||
return user
|
||
|
||
|
||
def current_user(request: Request, db: Session = Depends(get_db)) -> User:
|
||
user = user_from_token(db, request.cookies.get(SESSION_COOKIE))
|
||
if user is None:
|
||
raise HTTPException(status_code=401, detail="请先登录")
|
||
request.state.user = user
|
||
return user
|
||
|
||
|
||
def require_level(menu: str, level: str = "rw"):
|
||
"""给个别高危接口用的显式授权依赖(除菜单写权限外还要求指定菜单可编辑)。"""
|
||
def dep(user: User = Depends(current_user)) -> User:
|
||
if LEVEL_RANK.get(user.menus.get(menu, ""), 0) < LEVEL_RANK.get(level, 0):
|
||
raise HTTPException(status_code=403, detail=f"需要「{MENU_LABELS.get(menu, menu)}」的可编辑权限")
|
||
return user
|
||
return dep
|