Добавить пароли, вход по Basic и Bearer-сессии в Redis

This commit is contained in:
2026-10-08 18:54:34 +03:00
parent 551c763d5e
commit db9edd8fd2
6 changed files with 451 additions and 0 deletions
+38
View File
@@ -0,0 +1,38 @@
from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers=None):
self.status = status
self.code = code
self.message = message
self.headers = headers
def invalid(message: str) -> ApiError:
return ApiError(400, "invalid_request", message)
def bad_credentials() -> ApiError:
# один и тот же ответ для неизвестного username и неверного пароля
return ApiError(
401, "unauthorized", "Неверное имя пользователя или пароль",
{"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
)
def unauthorized() -> ApiError:
return ApiError(
401, "unauthorized", "Нужен действующий Bearer-токен",
{"WWW-Authenticate": 'Bearer realm="messenger"'},
)
def not_found() -> ApiError:
# одинаковый ответ для несуществующего и чужого объекта
return ApiError(404, "not_found", "Объект не найден")
def error_response(request_id: str, status: int, code: str, message: str, headers=None) -> JSONResponse:
body = {"error": {"code": code, "message": message, "request_id": request_id}}
return JSONResponse(body, status_code=status, headers=headers)
+11
View File
@@ -0,0 +1,11 @@
"""Проверка для Docker HEALTHCHECK: код 0, если /health/ready отвечает 200."""
import os
import sys
import urllib.request
port = os.getenv("APP_PORT", "8080")
try:
with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=4) as response:
sys.exit(0 if response.status == 200 else 1)
except Exception:
sys.exit(1)
+273
View File
@@ -0,0 +1,273 @@
import base64
import json
import logging
import re
import sys
import time
import uuid
from contextlib import asynccontextmanager
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from uuid import UUID
import psycopg
import redis
import uvicorn
from fastapi import Depends, FastAPI, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException
import config
import security
from errors import ApiError, bad_credentials, error_response, invalid, not_found, unauthorized
from schemas import CreateChat, CreateMessage, CreateUser
from sessions import Sessions
from store import Store, UnknownMember, UsernameTaken, timestamp
logging.basicConfig(
level=config.LOG_LEVEL.upper(),
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
stream=sys.stdout,
)
log = logging.getLogger("messenger")
if config.SESSION_STORE != "redis":
sys.exit("поддерживается только SESSION_STORE=redis")
USERNAME = re.compile(r"[a-z0-9_]{3,32}")
store = Store(config.database_url())
sessions = Sessions(config.cache_url())
@asynccontextmanager
async def lifespan(app: FastAPI):
store.open()
log.info(
"started env=%s listen=%s:%d session_ttl=%ds db_pool_max=%d",
config.ENV, config.HOST, config.PORT, config.SESSION_TTL_SECONDS, config.DB_POOL_MAX_SIZE,
)
yield
store.close()
sessions.close()
log.info("stopped")
app = FastAPI(title="MTUSI Messenger lab2", lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
@app.middleware("http")
async def request_context(request: Request, call_next):
request_id = uuid.uuid4().hex
request.state.request_id = request_id
started = time.perf_counter()
try:
response = await call_next(request)
except Exception:
log.exception("unhandled error request_id=%s", request_id)
response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера")
response.headers["X-Request-Id"] = request_id
# в лог идут только метод, путь и код ответа: тела запросов, пароли и токены не пишем
log.info(
"%s %s status=%d duration_ms=%.1f request_id=%s",
request.method, request.url.path, response.status_code,
(time.perf_counter() - started) * 1000, request_id,
)
return response
@app.exception_handler(ApiError)
async def on_api_error(request: Request, exc: ApiError):
return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def on_validation_error(request: Request, exc: RequestValidationError):
first = exc.errors()[0]
where = ".".join(str(part) for part in first["loc"])
return error_response(request.state.request_id, 400, "invalid_request", f"{where}: {first['msg']}")
@app.exception_handler(HTTPException)
async def on_http_error(request: Request, exc: HTTPException):
# сюда попадают ошибки самого фреймворка: неизвестный путь, неподдерживаемый метод
if exc.status_code == 404:
code, message = "not_found", "Объект не найден"
else:
code, message = "invalid_request", "Запрос не поддерживается"
return error_response(request.state.request_id, exc.status_code, code, message, exc.headers)
# OperationalError — нет связи с PostgreSQL, не дождались соединения из пула или сработал statement_timeout
@app.exception_handler(psycopg.OperationalError)
async def on_database_down(request: Request, exc: Exception):
log.warning("postgres unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@app.exception_handler(redis.RedisError)
async def on_cache_down(request: Request, exc: Exception):
log.warning("redis unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@dataclass
class Session:
user_id: str
token: str
def current_session(request: Request) -> Session:
# X-User-Id из lab1 здесь не читается вообще, Basic на бизнес-запросах тоже не принимается
token = security.parse_bearer(request.headers.get("Authorization"))
if token is None:
raise unauthorized()
# если Redis недоступен, здесь будет исключение и ответ 503: без проверки сессии запрос дальше не идёт
user_id = sessions.user_id(token)
if user_id is None:
raise unauthorized()
return Session(user_id, token)
def encode_cursor(scope: str, item: dict) -> str:
raw = json.dumps([scope, item["created_at"], item["id"]])
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(scope: str, cursor):
"""Возвращает ключ (created_at, id) последней выданной записи или None для первой страницы."""
if cursor is None:
return None
try:
cursor_scope, created_at, item_id = json.loads(base64.urlsafe_b64decode(cursor.encode()))
key = [datetime.strptime(created_at, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=timezone.utc), str(UUID(item_id))]
except (TypeError, ValueError, AttributeError):
raise invalid("Некорректный cursor")
# cursor действует только для того списка, в котором был выдан
if cursor_scope != scope:
raise invalid("Некорректный cursor")
return key
def page(scope: str, items: list, has_more: bool) -> dict:
next_cursor = encode_cursor(scope, items[-1]) if has_more else None
return {"items": items, "next_cursor": next_cursor}
@app.get("/health/live")
def liveness():
return {"status": "ok"}
@app.get("/health/ready")
def readiness():
# без PostgreSQL и Redis обязательные запросы не выполнить, поэтому обе зависимости критичны
store.ping()
sessions.ping()
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def register_user(body: CreateUser):
try:
return store.create_user(body.username, body.display_name, security.hash_password(body.password))
except UsernameTaken:
raise ApiError(409, "conflict", "Такой username уже занят")
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request):
credentials = security.parse_basic(request.headers.get("Authorization"))
if credentials is None:
raise bad_credentials()
username, password = credentials
user, password_hash = None, None
# username, который не мог быть зарегистрирован, в БД не ищем, но пароль всё равно сверяем с пустышкой
if USERNAME.fullmatch(username):
user, password_hash = store.get_credentials(username)
if not security.verify_password(password_hash, password):
raise bad_credentials()
token = sessions.create(user["id"])
expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
return {"token": token, "token_type": "Bearer", "expires_at": timestamp(expires_at), "user": user}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(session: Session = Depends(current_session)):
sessions.revoke(session.token)
return Response(status_code=204)
@app.get("/api/v1/users/me")
def get_me(session: Session = Depends(current_session)):
user = store.get_user(session.user_id)
if user is None:
raise unauthorized()
return user
@app.post("/api/v1/chats", status_code=201)
def create_chat(body: CreateChat, session: Session = Depends(current_session)):
member_ids = [str(member) for member in body.member_ids]
if len(set(member_ids)) != len(member_ids):
raise invalid("member_ids содержит повторы")
if session.user_id not in member_ids:
raise invalid("Создатель чата должен быть в member_ids")
try:
return store.create_chat(body.title, member_ids)
except UnknownMember:
raise invalid("В member_ids есть несуществующий пользователь")
@app.get("/api/v1/chats")
def list_chats(
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1),
session: Session = Depends(current_session),
):
scope = "chats:" + session.user_id
items, has_more = store.list_chats(session.user_id, decode_cursor(scope, cursor), limit)
return page(scope, items, has_more)
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: UUID, session: Session = Depends(current_session)):
chat = store.get_chat(str(chat_id), session.user_id)
if chat is None:
raise not_found()
return chat
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def send_message(chat_id: UUID, body: CreateMessage, session: Session = Depends(current_session)):
# отправитель берётся из сессии, в теле запроса его нет
message = store.add_message(str(chat_id), session.user_id, body.text)
if message is None:
raise not_found()
return message
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: UUID,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1),
session: Session = Depends(current_session),
):
scope = "messages:" + str(chat_id)
result = store.list_messages(str(chat_id), session.user_id, decode_cursor(scope, cursor), limit)
if result is None:
raise not_found()
items, has_more = result
return page(scope, items, has_more)
if __name__ == "__main__":
uvicorn.run(
app,
host=config.HOST,
port=config.PORT,
log_level=config.LOG_LEVEL,
access_log=False,
timeout_graceful_shutdown=config.SHUTDOWN_TIMEOUT,
)
+38
View File
@@ -0,0 +1,38 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
def not_blank(value: str) -> str:
if not value.strip():
raise ValueError("строка не может состоять только из пробелов")
# PostgreSQL не хранит символ NUL в text, а одиночные суррогаты нельзя записать в UTF-8
if "\x00" in value or any(0xD800 <= ord(char) <= 0xDFFF for char in value):
raise ValueError("строка содержит недопустимые символы")
return value
class StrictModel(BaseModel):
# лишние поля в JSON считаются ошибкой
model_config = ConfigDict(extra="forbid")
class CreateUser(StrictModel):
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
_not_blank = field_validator("display_name", "password")(not_blank)
class CreateChat(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: list[UUID] = Field(min_length=1, max_length=100)
_title = field_validator("title")(not_blank)
class CreateMessage(StrictModel):
text: str = Field(min_length=1, max_length=4000)
_text = field_validator("text")(not_blank)
+44
View File
@@ -0,0 +1,44 @@
import base64
import binascii
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
# Argon2id, параметры из рекомендаций OWASP: 19 МиБ памяти, 2 прохода, 1 поток
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
# с этим hash сверяется пароль, когда пользователя нет: время ответа не выдаёт, существует ли username
DUMMY_HASH = hasher.hash("no-such-user-password")
def hash_password(password: str) -> str:
return hasher.hash(password)
def verify_password(password_hash, password: str) -> bool:
try:
return hasher.verify(password_hash or DUMMY_HASH, password) and password_hash is not None
except (VerificationError, InvalidHashError):
return False
def parse_basic(header):
"""Разбирает Authorization: Basic base64(username:password). Возвращает пару или None."""
scheme, _, value = (header or "").partition(" ")
if scheme.lower() != "basic":
return None
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
return None
# двоеточие в пароле допустимо, поэтому делим только по первому
username, colon, password = decoded.partition(":")
if not colon:
return None
return username, password
def parse_bearer(header):
scheme, _, token = (header or "").partition(" ")
if scheme.lower() != "bearer" or not token.strip():
return None
return token.strip()
+47
View File
@@ -0,0 +1,47 @@
import hashlib
import secrets
import redis
from redis.backoff import NoBackoff
from redis.retry import Retry
import config
class Sessions:
"""Сессии лежат только в Redis: ключ session:<sha256 токена>, значение id пользователя, TTL ставит сам Redis."""
def __init__(self, url: str):
pool = redis.BlockingConnectionPool.from_url(
url,
max_connections=config.CACHE_POOL_MAX_SIZE,
timeout=config.CACHE_TIMEOUT, # ожидание свободного соединения
socket_timeout=config.CACHE_TIMEOUT,
socket_connect_timeout=config.CACHE_TIMEOUT,
decode_responses=True,
# одна повторная попытка без паузы: её хватает после перезапуска Redis, а при отказе ответ не затягивается
retry=Retry(NoBackoff(), 1),
)
self.client = redis.Redis(connection_pool=pool)
@staticmethod
def key(token: str) -> str:
# сам токен в Redis не хранится: по дампу нельзя войти от чужого имени
return "session:" + hashlib.sha256(token.encode()).hexdigest()
def create(self, user_id: str) -> str:
token = secrets.token_urlsafe(32) # 256 бит случайности
self.client.set(self.key(token), user_id, ex=config.SESSION_TTL_SECONDS)
return token
def user_id(self, token: str):
return self.client.get(self.key(token))
def revoke(self, token: str) -> None:
self.client.delete(self.key(token))
def ping(self) -> None:
self.client.ping()
def close(self) -> None:
self.client.close()