382 lines
16 KiB
Python
382 lines
16 KiB
Python
"""
|
||
Единый middleware для обработки авторизации в GraphQL запросах
|
||
"""
|
||
|
||
import time
|
||
from collections.abc import Awaitable, MutableMapping
|
||
from typing import Any, Callable
|
||
|
||
from graphql import GraphQLResolveInfo
|
||
from sqlalchemy.orm import exc
|
||
from starlette.authentication import UnauthenticatedUser
|
||
from starlette.requests import Request
|
||
from starlette.responses import JSONResponse, Response
|
||
from starlette.types import ASGIApp
|
||
|
||
from auth.credentials import AuthCredentials
|
||
from auth.tokens.storage import TokenStorage as TokenManager
|
||
from orm.author import Author
|
||
from settings import (
|
||
ADMIN_EMAILS as ADMIN_EMAILS_LIST,
|
||
)
|
||
from settings import (
|
||
SESSION_COOKIE_DOMAIN,
|
||
SESSION_COOKIE_HTTPONLY,
|
||
SESSION_COOKIE_NAME,
|
||
SESSION_COOKIE_SAMESITE,
|
||
SESSION_COOKIE_SECURE,
|
||
SESSION_TOKEN_HEADER,
|
||
)
|
||
from storage.db import local_session
|
||
from utils.logger import root_logger as logger
|
||
|
||
ADMIN_EMAILS = ADMIN_EMAILS_LIST.split(",")
|
||
|
||
|
||
class AuthenticatedUser:
|
||
"""Аутентифицированный пользователь"""
|
||
|
||
def __init__(
|
||
self,
|
||
user_id: str,
|
||
username: str = "",
|
||
roles: list | None = None,
|
||
permissions: dict | None = None,
|
||
token: str | None = None,
|
||
) -> None:
|
||
self.user_id = user_id
|
||
self.username = username
|
||
self.roles = roles or []
|
||
self.permissions = permissions or {}
|
||
self.token = token
|
||
|
||
@property
|
||
def is_authenticated(self) -> bool:
|
||
return True
|
||
|
||
@property
|
||
def display_name(self) -> str:
|
||
return self.username
|
||
|
||
@property
|
||
def identity(self) -> str:
|
||
return self.user_id
|
||
|
||
|
||
class AuthMiddleware:
|
||
"""
|
||
Единый middleware для обработки авторизации и аутентификации.
|
||
|
||
Основные функции:
|
||
1. Извлечение Bearer токена из заголовка Authorization или cookie
|
||
2. Проверка сессии через TokenStorage
|
||
3. Создание request.user и request.auth
|
||
4. Предоставление методов для установки/удаления cookies
|
||
"""
|
||
|
||
def __init__(self, app: ASGIApp) -> None:
|
||
self.app = app
|
||
self._context = None
|
||
|
||
async def authenticate_user(self, token: str) -> tuple[AuthCredentials, AuthenticatedUser | UnauthenticatedUser]:
|
||
"""Аутентифицирует пользователя по токену"""
|
||
if not token:
|
||
return AuthCredentials(
|
||
author_id=None, scopes={}, logged_in=False, error_message="no token", email=None, token=None
|
||
), UnauthenticatedUser()
|
||
|
||
# Проверяем сессию в Redis
|
||
try:
|
||
payload = await TokenManager.verify_session(token)
|
||
if not payload:
|
||
logger.debug("[auth.authenticate] Недействительный токен или сессия не найдена")
|
||
return AuthCredentials(
|
||
author_id=None,
|
||
scopes={},
|
||
logged_in=False,
|
||
error_message="Invalid token or session",
|
||
email=None,
|
||
token=None,
|
||
), UnauthenticatedUser()
|
||
|
||
with local_session() as session:
|
||
try:
|
||
# payload может быть словарем или объектом, обрабатываем оба случая
|
||
user_id = payload.user_id if hasattr(payload, "user_id") else payload.get("user_id")
|
||
if not user_id:
|
||
logger.debug("[auth.authenticate] user_id не найден в payload")
|
||
return AuthCredentials(
|
||
author_id=None,
|
||
scopes={},
|
||
logged_in=False,
|
||
error_message="Invalid token payload",
|
||
email=None,
|
||
token=None,
|
||
), UnauthenticatedUser()
|
||
|
||
author = session.query(Author).where(Author.id == user_id).one()
|
||
|
||
if author.is_locked():
|
||
logger.debug(f"[auth.authenticate] Аккаунт заблокирован: {author.id}")
|
||
return AuthCredentials(
|
||
author_id=None,
|
||
scopes={},
|
||
logged_in=False,
|
||
error_message="Account is locked",
|
||
email=None,
|
||
token=None,
|
||
), UnauthenticatedUser()
|
||
|
||
# Создаем пустой словарь разрешений
|
||
# Разрешения будут проверяться через RBAC систему по требованию
|
||
scopes: dict[str, Any] = {}
|
||
|
||
# Роли пользователя будут определяться в контексте конкретной операции
|
||
# через RBAC систему, а не здесь
|
||
roles: list[str] = []
|
||
|
||
# Обновляем last_seen
|
||
author.last_seen = int(time.time())
|
||
session.commit()
|
||
|
||
# Создаем объекты авторизации с сохранением токена
|
||
credentials = AuthCredentials(
|
||
author_id=author.id,
|
||
scopes=scopes,
|
||
logged_in=True,
|
||
error_message="",
|
||
email=author.email,
|
||
token=token,
|
||
)
|
||
|
||
user = AuthenticatedUser(
|
||
user_id=str(author.id),
|
||
username=author.slug or author.email or "",
|
||
roles=roles,
|
||
permissions=scopes,
|
||
token=token,
|
||
)
|
||
|
||
logger.debug(f"[auth.authenticate] Успешная аутентификация: {author.email}")
|
||
return credentials, user
|
||
|
||
except exc.NoResultFound:
|
||
logger.debug("[auth.authenticate] Пользователь не найден в базе данных")
|
||
return AuthCredentials(
|
||
author_id=None,
|
||
scopes={},
|
||
logged_in=False,
|
||
error_message="User not found",
|
||
email=None,
|
||
token=None,
|
||
), UnauthenticatedUser()
|
||
except Exception as e:
|
||
logger.warning(f"[auth.authenticate] Ошибка при работе с базой данных: {e}")
|
||
return AuthCredentials(
|
||
author_id=None, scopes={}, logged_in=False, error_message=str(e), email=None, token=None
|
||
), UnauthenticatedUser()
|
||
except Exception as e:
|
||
logger.warning(f"[auth.authenticate] Ошибка при проверке сессии: {e}")
|
||
return AuthCredentials(
|
||
author_id=None, scopes={}, logged_in=False, error_message=str(e), email=None, token=None
|
||
), UnauthenticatedUser()
|
||
|
||
async def __call__(
|
||
self,
|
||
scope: MutableMapping[str, Any],
|
||
receive: Callable[[], Awaitable[MutableMapping[str, Any]]],
|
||
send: Callable[[MutableMapping[str, Any]], Awaitable[None]],
|
||
) -> None:
|
||
"""Обработка ASGI запроса"""
|
||
if scope["type"] != "http":
|
||
await self.app(scope, receive, send)
|
||
return
|
||
|
||
# Извлекаем заголовки используя тот же механизм, что и get_safe_headers
|
||
headers = {}
|
||
|
||
# Первый приоритет: scope из ASGI (самый надежный источник)
|
||
if "headers" in scope:
|
||
scope_headers = scope.get("headers", [])
|
||
if scope_headers:
|
||
headers.update({k.decode("utf-8").lower(): v.decode("utf-8") for k, v in scope_headers})
|
||
|
||
# Используем тот же механизм получения токена, что и в декораторе
|
||
token = None
|
||
|
||
# 0. Проверяем сохраненный токен в scope (приоритет)
|
||
if "auth_token" in scope:
|
||
token = scope["auth_token"]
|
||
|
||
# 1. Проверяем заголовок Authorization
|
||
if not token:
|
||
auth_header = headers.get("authorization", "")
|
||
if auth_header:
|
||
token = auth_header[7:].strip() if auth_header.startswith("Bearer ") else auth_header.strip()
|
||
|
||
# 2. Проверяем основной заголовок авторизации, если Authorization не найден
|
||
if not token:
|
||
auth_header = headers.get(SESSION_TOKEN_HEADER.lower(), "")
|
||
if auth_header:
|
||
token = auth_header[7:].strip() if auth_header.startswith("Bearer ") else auth_header.strip()
|
||
|
||
# 3. Проверяем cookie
|
||
if not token:
|
||
cookies = headers.get("cookie", "")
|
||
if cookies:
|
||
cookie_items = cookies.split(";")
|
||
for item in cookie_items:
|
||
if "=" in item:
|
||
name, value = item.split("=", 1)
|
||
cookie_name = name.strip()
|
||
if cookie_name == SESSION_COOKIE_NAME:
|
||
token = value.strip()
|
||
break
|
||
|
||
# Аутентифицируем пользователя
|
||
auth, user = await self.authenticate_user(token or "")
|
||
|
||
# Добавляем в scope данные авторизации и пользователя
|
||
scope["auth"] = auth
|
||
scope["user"] = user
|
||
|
||
# Сохраняем токен в scope для использования в последующих запросах
|
||
if token:
|
||
scope["auth_token"] = token
|
||
|
||
await self.app(scope, receive, send)
|
||
|
||
def set_context(self, context) -> None:
|
||
"""Сохраняет ссылку на контекст GraphQL запроса"""
|
||
self._context = context
|
||
|
||
def set_cookie(self, key: str, value: str, **options: Any) -> None:
|
||
"""
|
||
Устанавливает cookie в ответе
|
||
|
||
Args:
|
||
key: Имя cookie
|
||
value: Значение cookie
|
||
**options: Дополнительные параметры (httponly, secure, max_age, etc.)
|
||
"""
|
||
success = False
|
||
|
||
# Способ 1: Через response
|
||
if self._context and "response" in self._context and hasattr(self._context["response"], "set_cookie"):
|
||
try:
|
||
self._context["response"].set_cookie(key, value, **options)
|
||
success = True
|
||
except Exception as e:
|
||
logger.error(f"[middleware] Ошибка при установке cookie {key} через response: {e!s}")
|
||
|
||
# Способ 2: Через собственный response в контексте
|
||
if not success and hasattr(self, "_response") and self._response and hasattr(self._response, "set_cookie"):
|
||
try:
|
||
self._response.set_cookie(key, value, **options)
|
||
success = True
|
||
except Exception as e:
|
||
logger.error(f"[middleware] Ошибка при установке cookie {key} через _response: {e!s}")
|
||
|
||
if not success:
|
||
logger.error(f"[middleware] Не удалось установить cookie {key}: объекты response недоступны")
|
||
|
||
def delete_cookie(self, key: str, **options: Any) -> None:
|
||
"""
|
||
Удаляет cookie из ответа
|
||
"""
|
||
success = False
|
||
|
||
# Способ 1: Через response
|
||
if self._context and "response" in self._context and hasattr(self._context["response"], "delete_cookie"):
|
||
try:
|
||
self._context["response"].delete_cookie(key, **options)
|
||
success = True
|
||
except Exception as e:
|
||
logger.error(f"[middleware] Ошибка при удалении cookie {key} через response: {e!s}")
|
||
|
||
# Способ 2: Через собственный response в контексте
|
||
if not success and hasattr(self, "_response") and self._response and hasattr(self._response, "delete_cookie"):
|
||
try:
|
||
self._response.delete_cookie(key, **options)
|
||
success = True
|
||
except Exception as e:
|
||
logger.error(f"[middleware] Ошибка при удалении cookie {key} через _response: {e!s}")
|
||
|
||
if not success:
|
||
logger.error(f"[middleware] Не удалось удалить cookie {key}: объекты response недоступны")
|
||
|
||
async def resolve(
|
||
self, next_resolver: Callable[..., Any], root: Any, info: GraphQLResolveInfo, *args: Any, **kwargs: Any
|
||
) -> Any:
|
||
"""
|
||
Middleware для обработки запросов GraphQL.
|
||
Добавляет методы для установки cookie в контекст.
|
||
"""
|
||
try:
|
||
# Получаем доступ к контексту запроса
|
||
context = info.context
|
||
|
||
# Сохраняем ссылку на контекст
|
||
self.set_context(context)
|
||
|
||
# Добавляем себя как объект, содержащий утилитные методы
|
||
context["extensions"] = self
|
||
|
||
# Проверяем наличие response в контексте
|
||
if "response" not in context or not context["response"]:
|
||
context["response"] = JSONResponse({})
|
||
|
||
return await next_resolver(root, info, *args, **kwargs)
|
||
except Exception as e:
|
||
logger.error(f"[AuthMiddleware] Ошибка в GraphQL resolve: {e!s}")
|
||
raise
|
||
|
||
async def process_result(self, request: Request, result: Any) -> Response:
|
||
"""
|
||
Обрабатывает результат GraphQL запроса, поддерживая установку cookie
|
||
|
||
Args:
|
||
request: Starlette Request объект
|
||
result: результат GraphQL запроса (dict или Response)
|
||
|
||
Returns:
|
||
Response: HTTP-ответ с результатом и cookie (если необходимо)
|
||
"""
|
||
|
||
# Проверяем, является ли result уже объектом Response
|
||
response = result if isinstance(result, Response) else JSONResponse(result)
|
||
|
||
# Проверяем, был ли токен в запросе или ответе
|
||
if request.method == "POST":
|
||
try:
|
||
data = await request.json()
|
||
op_name = data.get("operationName", "").lower()
|
||
|
||
# Если это операция logout, удаляем cookie
|
||
if op_name == "logout":
|
||
response.delete_cookie(
|
||
key=SESSION_COOKIE_NAME,
|
||
secure=SESSION_COOKIE_SECURE,
|
||
httponly=SESSION_COOKIE_HTTPONLY,
|
||
samesite=SESSION_COOKIE_SAMESITE
|
||
if SESSION_COOKIE_SAMESITE in ["strict", "lax", "none"]
|
||
else "none",
|
||
domain=SESSION_COOKIE_DOMAIN,
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"[process_result] Ошибка при обработке POST запроса: {e!s}")
|
||
|
||
return response
|
||
|
||
|
||
# Создаем единый экземпляр AuthMiddleware для использования с GraphQL
|
||
async def _dummy_app(
|
||
scope: MutableMapping[str, Any],
|
||
receive: Callable[[], Awaitable[MutableMapping[str, Any]]],
|
||
send: Callable[[MutableMapping[str, Any]], Awaitable[None]],
|
||
) -> None:
|
||
"""Dummy ASGI app for middleware initialization"""
|
||
|
||
|
||
auth_middleware = AuthMiddleware(_dummy_app)
|