fix(api): security, caching, atomic rate limits, url obfuscation

Redis:
- Singleton ConnectionPool (redis.asyncio), 50 connections — не создаём
  новое TCP-соединение на каждый HTTP-запрос

Rate limiter:
- Полностью переписан на async/await
- Lua-скрипт _LUA_CHECK_AND_INCR — атомарная проверка+инкремент без race condition
- Lua-скрипт _LUA_ACQUIRE_CONCURRENT — атомарный захват слота задачи
- Старый паттерн INCR→check→DECR удалён (race condition при конкурентных запросах)

Security:
- get_current_user кэширует пользователя в Redis на 5 минут (TTL)
  Раньше: SELECT users на каждый HTTP-запрос
  Теперь: Redis GET (кэш) → SELECT users (только при промахе)
- hashed_password НЕ кладётся в кэш
- invalidate_user_cache() для сброса при смене тарифа/пароля
- get_ws_user() для WebSocket через ?token=JWT (браузеры не могут
  передавать Authorization header при WS-handshake)

WebSocket:
- Добавлена аутентификация (Depends(get_ws_user))
- Проверка ownership задачи ДО accept() соединения
- Чужой task_id → закрытие с кодом 4004

URL obfuscation:
- Task.public_id = secrets.token_urlsafe(16) = 22 случайных base64url символа
- Клиент работает только с public_id, внутренний UUID не раскрывается
- Все роутеры переключены на public_id в WHERE условиях
- TaskResponse больше не возвращает input_data (там minio_key и т.д.)
- Миграция 002_add_task_public_id.py

MinIO:
- Singleton клиент (не создаём новый на каждый upload)
- ensure_bucket() вызывается один раз при старте (lifespan), не на каждый запрос
- Путь uploads/{doc_uuid}{ext} — user_id убран из пути

CORS:
- Убраны wildcard allow_methods/allow_headers (несовместимы с credentials=True)
- Явный список: methods=[GET,POST,DELETE,OPTIONS], headers=[Authorization,Content-Type,Accept]
- Swagger/OpenAPI доступны только в ENVIRONMENT=development

Documents:
- Content-Length проверяется ДО чтения тела (ранняя отбивка больших файлов)
- Повторная проверка реального размера после чтения (защита от поддельного заголовка)
- Используем get_current_verified_user вместо get_current_user (требуем подтверждённый email)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

services/api/app/core/security.py

@@ -1,9 +1,11 @@
-"""Утилиты безопасности: JWT, хэширование паролей, dependency для получения текущего пользователя."""
+"""JWT, хэширование паролей, dependency получения пользователя с кэшированием."""
 
+import json
+import logging
 from datetime import datetime, timedelta, timezone
 from typing import Any
 
-from fastapi import Depends, HTTPException, status
+from fastapi import Depends, HTTPException, Query, WebSocket, status
 from fastapi.security import OAuth2PasswordBearer
 from jose import JWTError, jwt
 from passlib.context import CryptContext
@@ -11,53 +13,47 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.config import settings
+from app.core.redis_client import get_redis
 from app.database import get_db
 
-# Контекст хэширования паролей (bcrypt)
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+logger = logging.getLogger(__name__)
 
-# OAuth2 схема
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
 
+# TTL кэша пользователя в Redis (5 минут)
+_USER_CACHE_TTL = 300
+
 
 def hash_password(password: str) -> str:
-    """Хэшировать пароль через bcrypt."""
     return pwd_context.hash(password)
 
 
-def verify_password(plain_password: str, hashed_password: str) -> bool:
-    """Проверить соответствие пароля его хэшу."""
-    return pwd_context.verify(plain_password, hashed_password)
+def verify_password(plain: str, hashed: str) -> bool:
+    return pwd_context.verify(plain, hashed)
 
 
 def create_access_token(data: dict[str, Any], expires_delta: timedelta | None = None) -> str:
-    """Создать JWT токен доступа."""
-    to_encode = data.copy()
+    payload = data.copy()
     expire = datetime.now(timezone.utc) + (
         expires_delta or timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
     )
-    to_encode.update({"exp": expire})
-    return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    payload["exp"] = expire
+    return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
 
 
-def verify_token(token: str) -> dict[str, Any]:
+def _decode_token(token: str) -> int:
     """
-    Декодировать и верифицировать JWT токен.
-
-    Raises:
-        HTTPException: если токен невалиден или просрочен.
+    Декодировать JWT и вернуть user_id.
+    Raises HTTPException 401 при любой проблеме с токеном.
     """
     try:
         payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
-        user_id: int | None = payload.get("sub")
-        if user_id is None:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Неверный токен аутентификации",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-        return payload
-    except JWTError:
+        sub = payload.get("sub")
+        if sub is None:
+            raise ValueError("missing sub")
+        return int(sub)
+    except (JWTError, ValueError):
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Невалидный или просроченный токен",
@@ -65,46 +61,79 @@ def verify_token(token: str) -> dict[str, Any]:
         )
 
 
-async def get_current_user(
-    token: str = Depends(oauth2_scheme),
-    db: AsyncSession = Depends(get_db),
-):
-    """
-    FastAPI dependency: получить текущего авторизованного пользователя из JWT токена.
+async def _load_user(user_id: int, db: AsyncSession):
+    """Загрузить пользователя из Redis-кэша или из БД."""
+    from app.models.user import User  # избегаем circular import на уровне модуля
 
-    Raises:
-        HTTPException 401: если токен невалиден.
-        HTTPException 404: если пользователь не найден.
-    """
-    from app.models.user import User
+    cache_key = f"user:cache:{user_id}"
+    r = get_redis()
 
-    payload = verify_token(token)
-    user_id: int = int(payload.get("sub"))
+    # Пробуем кэш
+    cached = await r.get(cache_key)
+    if cached:
+        data = json.loads(cached)
+        # Возвращаем "живой" объект из БД только по id, но без лишнего SELECT
+        # Создаём User без ORM-связей (достаточно для проверок в роутерах)
+        u = User.__new__(User)
+        u.__dict__.update(data)
+        return u
 
+    # Кэш пустой — идём в БД
     result = await db.execute(select(User).where(User.id == user_id))
     user = result.scalar_one_or_none()
 
     if user is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Пользователь не найден",
-        )
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Пользователь не найден")
+
+    # Сохраняем в кэш (только безопасные поля, без hashed_password)
+    safe = {
+        "id": user.id,
+        "email": user.email,
+        "name": user.name,
+        "plan": user.plan,
+        "is_verified": user.is_verified,
+    }
+    await r.setex(cache_key, _USER_CACHE_TTL, json.dumps(safe))
 
     return user
 
 
-async def get_current_verified_user(
-    current_user=Depends(get_current_user),
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_db),
 ):
-    """
-    FastAPI dependency: только верифицированные пользователи.
+    """Dependency: текущий пользователь из JWT с Redis-кэшем."""
+    user_id = _decode_token(token)
+    return await _load_user(user_id, db)
 
-    Raises:
-        HTTPException 403: если email не подтверждён.
-    """
+
+async def get_current_verified_user(current_user=Depends(get_current_user)):
+    """Dependency: только верифицированные пользователи."""
     if not current_user.is_verified:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Необходимо подтвердить email адрес",
         )
     return current_user
+
+
+async def get_ws_user(
+    websocket: WebSocket,
+    token: str = Query(..., description="JWT токен (передаётся как query-параметр ?token=...)"),
+    db: AsyncSession = Depends(get_db),
+):
+    """
+    Dependency для WebSocket: аутентификация через query-параметр ?token=JWT.
+
+    WebSocket API браузера не позволяет передавать Authorization header,
+    поэтому токен передаётся в query-строке:
+        ws://host/ws/tasks/{public_id}?token=<JWT>
+    """
+    user_id = _decode_token(token)
+    return await _load_user(user_id, db)
+
+
+async def invalidate_user_cache(user_id: int) -> None:
+    """Сбросить кэш пользователя (при смене тарифа, пароля и т.д.)."""
+    r = get_redis()
+    await r.delete(f"user:cache:{user_id}")