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.
189 lines
6.3 KiB
Python
189 lines
6.3 KiB
Python
"""Password verification and short-lived, server-side account 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
|
|
# Immutable database primary key. The optional form is only for the
|
|
# injected, database-free HTTP test harness.
|
|
user_id: int | None = None
|
|
|
|
|
|
class SessionStore:
|
|
def __init__(self) -> None:
|
|
self._sessions: dict[str, Session] = {}
|
|
self._lock = threading.Lock()
|
|
|
|
def issue(self, username: str, user_id: int | None = None) -> Session:
|
|
session = Session(
|
|
token=secrets.token_urlsafe(32),
|
|
username=username,
|
|
csrf_token=secrets.token_urlsafe(32),
|
|
expires_at=time.time() + SESSION_LIFETIME_SECONDS,
|
|
user_id=user_id,
|
|
)
|
|
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 immutable user ID, 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, user_id: int | None = None) -> Session:
|
|
if isinstance(user_id, bool) or not isinstance(user_id, int) or user_id < 1:
|
|
raise ValueError("Database sessions require a positive user ID")
|
|
session = Session(
|
|
token=secrets.token_urlsafe(32),
|
|
username=username,
|
|
csrf_token=secrets.token_urlsafe(32),
|
|
expires_at=time.time() + SESSION_LIFETIME_SECONDS,
|
|
user_id=user_id,
|
|
)
|
|
payload = json.dumps({
|
|
"username": session.username,
|
|
"user_id": session.user_id,
|
|
"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"]
|
|
user_id = data["user_id"]
|
|
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 isinstance(user_id, bool) or not isinstance(user_id, int) or user_id < 1
|
|
or isinstance(expires_at, bool) 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), user_id)
|
|
|
|
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)
|