You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/virsh_panel/auth.py

179 lines
5.7 KiB
Python

"""Password verification and short-lived, server-side administrator sessions."""
from __future__ import annotations
import hashlib
import hmac
import json
import secrets
import threading
import time
from dataclasses import dataclass
from typing import Protocol
PASSWORD_ITERATIONS = 600_000
SESSION_LIFETIME_SECONDS = 8 * 60 * 60
def hash_password(password: str) -> str:
if len(password) < 12:
raise ValueError("Password must contain at least 12 characters")
salt = secrets.token_bytes(16)
digest = hashlib.pbkdf2_hmac(
"sha256", password.encode("utf-8"), salt, PASSWORD_ITERATIONS
)
return f"pbkdf2_sha256${PASSWORD_ITERATIONS}${salt.hex()}${digest.hex()}"
def verify_password(password: str, encoded: str) -> bool:
try:
algorithm, iterations_raw, salt_raw, expected_raw = encoded.split("$")
iterations = int(iterations_raw)
if algorithm != "pbkdf2_sha256" or not 100_000 <= iterations <= 2_000_000:
return False
salt = bytes.fromhex(salt_raw)
expected = bytes.fromhex(expected_raw)
if len(salt) < 16 or len(expected) != 32:
return False
except (ValueError, TypeError):
return False
actual = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations)
return hmac.compare_digest(actual, expected)
@dataclass(frozen=True)
class Session:
token: str
username: str
csrf_token: str
expires_at: float
class SessionStore:
def __init__(self) -> None:
self._sessions: dict[str, Session] = {}
self._lock = threading.Lock()
def issue(self, username: str) -> Session:
session = Session(
token=secrets.token_urlsafe(32),
username=username,
csrf_token=secrets.token_urlsafe(32),
expires_at=time.time() + SESSION_LIFETIME_SECONDS,
)
with self._lock:
self._sessions[session.token] = session
return session
def get(self, token: str | None) -> Session | None:
if not token:
return None
with self._lock:
session = self._sessions.get(token)
if session is None:
return None
if session.expires_at <= time.time():
self._sessions.pop(token, None)
return None
return session
def revoke(self, token: str | None) -> None:
if token:
with self._lock:
self._sessions.pop(token, None)
class _SessionDatabase(Protocol):
def get(self, record_type: str, record_key: str) -> str | None: ...
def set(self, record_type: str, record_key: str, value: str) -> None: ...
def delete(self, record_type: str, record_key: str) -> None: ...
class DatabaseSessionStore:
"""Server-side sessions that survive a web-process restart.
Only a SHA-256 fingerprint of the bearer token is used as the database
record key. The username, CSRF token and expiry are encrypted by the
database store; the raw bearer token is never persisted.
"""
def __init__(self, database: _SessionDatabase) -> None:
self._database = database
@staticmethod
def _key(token: str) -> str:
return hashlib.sha256(token.encode("ascii")).hexdigest()
def issue(self, username: str) -> Session:
session = Session(
token=secrets.token_urlsafe(32),
username=username,
csrf_token=secrets.token_urlsafe(32),
expires_at=time.time() + SESSION_LIFETIME_SECONDS,
)
payload = json.dumps({
"username": session.username,
"csrf_token": session.csrf_token,
"expires_at": session.expires_at,
}, separators=(",", ":"))
self._database.set("session", self._key(session.token), payload)
return session
def get(self, token: str | None) -> Session | None:
if not isinstance(token, str) or not token or len(token) > 256:
return None
try:
key = self._key(token)
except UnicodeEncodeError:
return None
raw = self._database.get("session", key)
if raw is None:
return None
try:
data = json.loads(raw)
username = data["username"]
csrf_token = data["csrf_token"]
expires_at = data["expires_at"]
except (TypeError, ValueError, KeyError):
return None
if (not isinstance(username, str) or not isinstance(csrf_token, str)
or not isinstance(expires_at, (int, float))):
return None
if expires_at <= time.time():
self._database.delete("session", key)
return None
return Session(token, username, csrf_token, float(expires_at))
def revoke(self, token: str | None) -> None:
if not isinstance(token, str) or not token or len(token) > 256:
return
try:
key = self._key(token)
except UnicodeEncodeError:
return
self._database.delete("session", key)
class LoginLimiter:
"""Small in-memory limit for failed logins from one peer address."""
def __init__(self) -> None:
self._failures: dict[str, list[float]] = {}
self._lock = threading.Lock()
def allowed(self, peer: str) -> bool:
cutoff = time.time() - 15 * 60
with self._lock:
recent = [attempt for attempt in self._failures.get(peer, []) if attempt > cutoff]
self._failures[peer] = recent
return len(recent) < 5
def failed(self, peer: str) -> None:
with self._lock:
self._failures.setdefault(peer, []).append(time.time())
def succeeded(self, peer: str) -> None:
with self._lock:
self._failures.pop(peer, None)