"""Admin and reviewer accounts. Roles: "admin" (projects, ethics, payments, users, and reviewing) and "reviewer" (review queue only). Passwords are stored as PBKDF2-SHA256 hashes. Sessions are random bearer tokens sent in the X-SCQC-Token header. The first admin is created either from SCQC_ADMIN_PASSWORD (user name from SCQC_ADMIN_USER, default "admin") at start-up, or through the setup screen, which requires the deployment's SCQC_ADMIN_TOKEN so a stranger who finds an empty server cannot claim it. The shared tokens keep working for scripts. """ from __future__ import annotations import hashlib import hmac import os import secrets import time from typing import Optional SCHEMA = """ CREATE TABLE IF NOT EXISTS users ( username TEXT PRIMARY KEY, display_name TEXT, role TEXT NOT NULL CHECK (role IN ('admin','reviewer','participant')), pw_hash TEXT NOT NULL, salt TEXT NOT NULL, created_at REAL NOT NULL, disabled INTEGER NOT NULL DEFAULT 0); CREATE TABLE IF NOT EXISTS sessions ( token TEXT PRIMARY KEY, username TEXT NOT NULL, created_at REAL NOT NULL, expires_at REAL NOT NULL); """ SESSION_DAYS = 7 ITERATIONS = 200_000 _failures: dict[str, list[float]] = {} def hash_password(password: str, salt: Optional[str] = None) -> tuple[str, str]: salt = salt or secrets.token_hex(16) h = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), bytes.fromhex(salt), ITERATIONS).hex() return h, salt def init(db) -> None: db._conn.executescript(SCHEMA) pw = os.environ.get("SCQC_ADMIN_PASSWORD") if pw and not db.one("SELECT 1 FROM users LIMIT 1"): create_user(db, os.environ.get("SCQC_ADMIN_USER", "admin"), pw, "admin", "Administrator") def has_users(db) -> bool: return db.one("SELECT 1 FROM users LIMIT 1") is not None def create_user(db, username: str, password: str, role: str, display_name: Optional[str] = None) -> dict: if len(password) < 10: raise ValueError("passwords need at least 10 characters") if not username or not username.replace("_", "").replace(".", "").replace("-", "").isalnum() or len(username) > 40: raise ValueError("user names use letters, digits, '.', '_' or '-' (max 40)") h, salt = hash_password(password) with db.tx() as c: c.execute("INSERT INTO users(username, display_name, role, pw_hash, salt, created_at) VALUES (?,?,?,?,?,?)", (username, display_name or username, role, h, salt, time.time())) db.log(c, "system", "user.created", username, {"role": role}) return {"username": username, "role": role, "display_name": display_name or username} def login(db, username: str, password: str) -> Optional[dict]: now = time.time() recent = [t for t in _failures.get(username, []) if now - t < 300] _failures[username] = recent if len(recent) >= 10: raise PermissionError("too many failed attempts; try again in a few minutes") u = db.one("SELECT * FROM users WHERE username=? AND disabled=0", (username,)) if not u or not hmac.compare_digest(hash_password(password, u["salt"])[0], u["pw_hash"]): _failures[username].append(now) return None token = secrets.token_urlsafe(32) with db.tx() as c: c.execute("INSERT INTO sessions(token, username, created_at, expires_at) VALUES (?,?,?,?)", (token, username, now, now + SESSION_DAYS * 86400)) c.execute("DELETE FROM sessions WHERE expires_at < ?", (now,)) db.log(c, username, "user.login", username, {}) return {"token": token, "username": username, "role": u["role"], "display_name": u["display_name"]} def session_user(db, token: Optional[str]) -> Optional[dict]: if not token: return None r = db.one("SELECT u.username, u.role, u.display_name FROM sessions s JOIN users u USING (username)" " WHERE s.token=? AND s.expires_at>? AND u.disabled=0", (token, time.time())) return dict(r) if r else None def logout(db, token: str) -> None: with db.tx() as c: c.execute("DELETE FROM sessions WHERE token=?", (token,))