Files
mtusi2026lab7/app/services/auth_service.py

234 lines
6.3 KiB
Python

import hashlib
import secrets
from datetime import datetime, timedelta, timezone
from redis import Redis
from redis.backoff import NoBackoff
from redis.exceptions import RedisError
from redis.retry import Retry
from sqlalchemy.orm import Session
from app.core.config import settings
from app.db.models import User
from app.repositories.session_repository import SessionRepository
from app.repositories.user_repository import UserRepository
from app.services.user_service import password_hasher
class InvalidCredentialsError(Exception):
pass
class InvalidSessionError(Exception):
pass
class LoginRateLimitError(Exception):
def __init__(self, retry_after: int):
self.retry_after = max(1, retry_after)
super().__init__("Too many login attempts")
class LoginRateLimitUnavailableError(Exception):
pass
class AuthService:
def __init__(self, db: Session):
self.db = db
self.sessions = SessionRepository(db)
self.users = UserRepository(db)
self._redis_available = True
self.redis = Redis.from_url(
settings.cache_url,
decode_responses=True,
socket_connect_timeout=0.5,
socket_timeout=0.5,
retry_on_timeout=False,
retry=Retry(NoBackoff(), 0),
)
@staticmethod
def _hash_token(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
@staticmethod
def _login_rate_key(username: str, client_ip: str) -> str:
identity = hashlib.sha256(
f"{username.strip().lower()}|{client_ip}".encode("utf-8")
).hexdigest()
return f"login-rate:{identity}"
def _check_login_rate(self, key: str) -> None:
try:
count = int(self.redis.get(key) or 0)
if count >= settings.login_rate_limit_attempts:
ttl = self.redis.ttl(key)
raise LoginRateLimitError(
ttl if ttl > 0 else settings.login_rate_limit_window_seconds
)
except LoginRateLimitError:
raise
except RedisError:
raise LoginRateLimitUnavailableError() from None
def _record_failed_login(self, key: str) -> None:
script = """
local count = redis.call('INCR', KEYS[1])
if count == 1 then
redis.call('EXPIRE', KEYS[1], ARGV[1])
end
local ttl = redis.call('TTL', KEYS[1])
return {count, ttl}
"""
try:
count, ttl = self.redis.eval(
script,
1,
key,
settings.login_rate_limit_window_seconds,
)
except RedisError:
raise LoginRateLimitUnavailableError() from None
if int(count) > settings.login_rate_limit_attempts:
raise LoginRateLimitError(
int(ttl) if int(ttl) > 0
else settings.login_rate_limit_window_seconds
)
def create_session(
self,
username: str,
password: str,
client_ip: str = "unknown",
) -> dict:
rate_key = self._login_rate_key(username, client_ip)
self._check_login_rate(rate_key)
user = self.users.get_by_username(username)
if user is None or not password_hasher.verify(
password, user.password_hash
):
self._record_failed_login(rate_key)
raise InvalidCredentialsError(
"Invalid username or password"
)
try:
self.redis.delete(rate_key)
except RedisError:
raise LoginRateLimitUnavailableError() from None
token = secrets.token_urlsafe(32)
token_hash = self._hash_token(token)
expires_at = datetime.now(timezone.utc) + timedelta(
seconds=settings.session_ttl_seconds
)
try:
self.sessions.create(
user_id=user.id,
token_hash=token_hash,
expires_at=expires_at,
)
self.db.commit()
except Exception:
self.db.rollback()
raise
self._cache_session(token_hash, user.id, expires_at)
return {
"token": token,
"token_type": "Bearer",
"expires_at": expires_at,
"user": user,
}
def _cache_session(
self,
token_hash: str,
user_id,
expires_at,
) -> None:
if not self._redis_available:
return
ttl = max(
1,
int((expires_at - datetime.now(timezone.utc)).total_seconds()),
)
try:
self.redis.setex(
f"session:{token_hash}",
ttl,
str(user_id),
)
except RedisError:
self._redis_available = False
def authenticate(self, token: str) -> User:
token_hash = self._hash_token(token)
cached_user_id = None
if self._redis_available:
try:
cached_user_id = self.redis.get(
f"session:{token_hash}"
)
except RedisError:
self._redis_available = False
session = self.sessions.get_valid_session(token_hash)
if session is None:
if self._redis_available:
try:
self.redis.delete(f"session:{token_hash}")
except RedisError:
self._redis_available = False
raise InvalidSessionError(
"Session is invalid or expired"
)
if cached_user_id is None:
self._cache_session(
token_hash,
session.user_id,
session.expires_at,
)
return session.user
def delete_session(self, token: str) -> None:
token_hash = self._hash_token(token)
try:
deleted = self.sessions.delete_by_token_hash(token_hash)
if not deleted:
raise InvalidSessionError(
"Session is invalid or expired"
)
self.db.commit()
except Exception:
self.db.rollback()
raise
if self._redis_available:
try:
self.redis.delete(f"session:{token_hash}")
except RedisError:
self._redis_available = False