forked from mtusi2026/mtusi2026lab2
94 lines
3.4 KiB
Python
94 lines
3.4 KiB
Python
"""scrypt passwords, strict Basic credentials and persistent signed cursors."""
|
|
import base64
|
|
from datetime import datetime, timezone
|
|
import hashlib
|
|
import hmac
|
|
import json
|
|
import re
|
|
import secrets
|
|
from uuid import UUID
|
|
|
|
from .errors import invalid, unauthorized
|
|
|
|
|
|
def password_hash(password, salt=None):
|
|
salt = salt or secrets.token_bytes(16)
|
|
digest = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=16384,
|
|
r=8, p=1, dklen=32, maxmem=64 * 1024 * 1024)
|
|
return "scrypt$16384$8$1$" + salt.hex() + "$" + digest.hex()
|
|
|
|
|
|
def password_matches(password, encoded):
|
|
try:
|
|
algorithm, n, r, p, salt, digest = encoded.split("$")
|
|
if (algorithm, n, r, p) != ("scrypt", "16384", "8", "1"):
|
|
return False
|
|
actual = password_hash(password, bytes.fromhex(salt)).rsplit("$", 1)[1]
|
|
return hmac.compare_digest(actual, digest)
|
|
except (ValueError, UnicodeError):
|
|
return False
|
|
|
|
|
|
def basic_credentials(header):
|
|
try:
|
|
scheme, encoded = header.split(" ", 1)
|
|
if scheme.lower() != "basic" or len(encoded) > 2048:
|
|
raise ValueError
|
|
value = base64.b64decode(encoded, validate=True).decode("utf-8")
|
|
username, password = value.split(":", 1)
|
|
if re.fullmatch(r"[a-z0-9_]{3,32}", username) is None:
|
|
raise ValueError
|
|
if not 12 <= len(password) <= 128:
|
|
raise ValueError
|
|
return username, password
|
|
except (AttributeError, ValueError, UnicodeError):
|
|
raise unauthorized(basic=True) from None
|
|
|
|
|
|
def bearer(header):
|
|
try:
|
|
scheme, token = header.split(" ", 1)
|
|
if scheme.lower() != "bearer" or re.fullmatch(r"[A-Za-z0-9_-]{43}", token) is None:
|
|
raise ValueError
|
|
return token
|
|
except (AttributeError, ValueError):
|
|
raise unauthorized() from None
|
|
|
|
|
|
def identifier(value):
|
|
try:
|
|
return UUID(value)
|
|
except (ValueError, AttributeError, TypeError):
|
|
raise invalid("Invalid UUID") from None
|
|
|
|
|
|
def stamp(value):
|
|
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
|
|
|
|
|
class Cursors:
|
|
def __init__(self, key):
|
|
self.key = key
|
|
|
|
def encode(self, scope, item):
|
|
payload = json.dumps([scope, item["created_at"], item["id"]], separators=(",", ":")).encode()
|
|
signature = hmac.digest(self.key, payload, hashlib.sha256)
|
|
return base64.urlsafe_b64encode(signature + payload).decode().rstrip("=")
|
|
|
|
def decode(self, scope, token):
|
|
try:
|
|
if not token or len(token) > 1024:
|
|
raise ValueError
|
|
raw = base64.b64decode(token + "=" * (-len(token) % 4), altchars=b"-_", validate=True)
|
|
signature, payload = raw[:32], raw[32:]
|
|
if not hmac.compare_digest(signature, hmac.digest(self.key, payload, hashlib.sha256)):
|
|
raise ValueError
|
|
parts = json.loads(payload)
|
|
if not isinstance(parts, list) or len(parts) != 3 or parts[0] != scope:
|
|
raise ValueError
|
|
if not all(isinstance(x, str) for x in parts) or not parts[1].endswith("Z"):
|
|
raise ValueError
|
|
return datetime.fromisoformat(parts[1].replace("Z", "+00:00")), UUID(parts[2])
|
|
except (ValueError, TypeError, UnicodeError):
|
|
raise invalid("Invalid cursor for this resource") from None
|