unis_manager/app/security.py

319 lines
13 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""登录与权限(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