Download server/auth.py from raianand/SCQC: direct link, hf CLI and curl.
- Browser
- Download file 4.07 kB
-
https://huggingface.co/spaces/raianand/SCQC/resolve/main/server/auth.py
- Command line
-
hf download hf://spaces/raianand/SCQC/server/auth.py
-
curl -L -o auth.py https://huggingface.co/spaces/raianand/SCQC/resolve/main/server/auth.py
4.07 kB
| """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,)) | |