forked from mtusi2026/mtusi2026lab2
131 lines
3.9 KiB
Python
131 lines
3.9 KiB
Python
import base64
|
|
import binascii
|
|
import uuid
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
import redis.asyncio as aioredis
|
|
from fastapi import APIRouter, Depends, Header, Request
|
|
from fastapi.responses import JSONResponse
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from src.api.deps import get_current_user
|
|
from src.core.config import settings
|
|
from src.core.redis import get_redis
|
|
from src.core.security import verify_password
|
|
from src.db.session import get_db
|
|
from src.models.models import User
|
|
from src.schemas.schemas import SessionResponse, UserResponse
|
|
from src.services import sessions as sessions_service
|
|
from src.services import users as users_service
|
|
|
|
|
|
router = APIRouter(prefix="/api/v1/auth/sessions", tags=["auth"])
|
|
|
|
|
|
def _rid(request: Request) -> str:
|
|
return getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
|
|
|
|
|
def _error(
|
|
status_code: int,
|
|
code: str,
|
|
message: str,
|
|
request: Request,
|
|
challenge: str | None = None,
|
|
) -> JSONResponse:
|
|
rid = _rid(request)
|
|
headers = {"X-Request-Id": rid}
|
|
if challenge:
|
|
headers["WWW-Authenticate"] = challenge
|
|
return JSONResponse(
|
|
status_code=status_code,
|
|
content={
|
|
"error": {
|
|
"code": code,
|
|
"message": message,
|
|
"request_id": rid,
|
|
}
|
|
},
|
|
headers=headers,
|
|
)
|
|
|
|
|
|
def _parse_basic(authorization: str | None) -> tuple[str, str] | None:
|
|
if not authorization or not authorization.lower().startswith("basic "):
|
|
return None
|
|
encoded = authorization.split(" ", 1)[1].strip()
|
|
try:
|
|
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
|
|
except (binascii.Error, UnicodeDecodeError):
|
|
return None
|
|
if ":" not in decoded:
|
|
return None
|
|
username, password = decoded.split(":", 1)
|
|
return username, password
|
|
|
|
|
|
@router.post("", status_code=201)
|
|
async def create_session(
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
db: AsyncSession = Depends(get_db),
|
|
redis: aioredis.Redis = Depends(get_redis),
|
|
):
|
|
credentials = _parse_basic(authorization)
|
|
if credentials is None:
|
|
return _error(
|
|
401, "unauthorized", "invalid credentials", request,
|
|
challenge='Basic realm="messenger", charset="UTF-8"',
|
|
)
|
|
|
|
username, password = credentials
|
|
user = await users_service.get_user_by_username(db, username)
|
|
if user is None or not verify_password(password, user.password_hash):
|
|
return _error(
|
|
401, "unauthorized", "invalid credentials", request,
|
|
challenge='Basic realm="messenger", charset="UTF-8"',
|
|
)
|
|
|
|
try:
|
|
token = await sessions_service.create_session(redis, user.id)
|
|
except (aioredis.RedisError, ConnectionError, OSError):
|
|
return _error(
|
|
503, "unavailable", "session store unavailable", request,
|
|
)
|
|
|
|
expires_at = datetime.now(timezone.utc) + timedelta(
|
|
seconds=settings.session_ttl_seconds
|
|
)
|
|
|
|
payload = SessionResponse(
|
|
token=token,
|
|
token_type="Bearer",
|
|
expires_at=expires_at,
|
|
user=UserResponse.model_validate(user),
|
|
)
|
|
return JSONResponse(
|
|
status_code=201,
|
|
content=payload.model_dump(mode="json"),
|
|
headers={"X-Request-Id": _rid(request)},
|
|
)
|
|
|
|
|
|
@router.delete("/current", status_code=204)
|
|
async def revoke_current_session(
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
current_user: User = Depends(get_current_user),
|
|
redis: aioredis.Redis = Depends(get_redis),
|
|
):
|
|
token = authorization.split(" ", 1)[1].strip()
|
|
try:
|
|
await sessions_service.revoke_session(redis, token)
|
|
except (aioredis.RedisError, ConnectionError, OSError):
|
|
return _error(
|
|
503, "unavailable", "session store unavailable", request,
|
|
)
|
|
return JSONResponse(
|
|
status_code=204,
|
|
content=None,
|
|
headers={"X-Request-Id": _rid(request)},
|
|
) |