File size: 8,336 Bytes
9cf9a2a
 
 
 
 
 
 
 
 
7435134
 
da2ad52
9cf9a2a
 
7435134
9cf9a2a
 
 
 
 
 
 
 
 
 
da2ad52
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9cf9a2a
 
 
 
d21ea1e
 
 
 
da2ad52
 
 
 
 
 
 
 
9cf9a2a
 
 
 
 
 
 
 
 
 
 
 
da2ad52
9cf9a2a
 
 
 
 
 
 
 
 
 
 
 
 
d21ea1e
 
 
 
 
 
 
da2ad52
 
 
 
 
9cf9a2a
 
d21ea1e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9cf9a2a
 
 
 
 
 
 
 
 
 
 
 
 
da2ad52
9cf9a2a
da2ad52
9cf9a2a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
d21ea1e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9cf9a2a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
"""
Authentication utilities for JuriX.

Provides JWT token generation, password hashing, and user authentication.

Author: JuriX Team
Date: 2026-01-12
"""

import base64
import hashlib
from datetime import datetime, timedelta, timezone
from typing import Optional

import bcrypt
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from jose import JWTError, jwt
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.config import settings
from app.core.database import get_db
from app.models.user import User

# ==================== HACHAGE DES MOTS DE PASSE ====================
#
# bcrypt est utilise directement, sans passlib. passlib 1.7.4 (derniere version,
# 2020) lit `bcrypt.__about__.__version__` pour detecter le backend — attribut
# supprime depuis bcrypt 4.1. Avec bcrypt 5.x, le hachage echouait totalement
# avec "password cannot be longer than 72 bytes" MEME pour un mot de passe de
# 13 caracteres. L'authentification etait donc inutilisable telle que declaree.
#
# bcrypt ignore silencieusement tout ce qui depasse 72 octets : deux mots de
# passe partageant les 72 premiers octets seraient equivalents. On pre-hache donc
# en SHA-256 puis on encode en base64, ce qui donne une entree de longueur fixe
# (44 octets) et supporte les phrases de passe de n'importe quelle longueur.


def _prepare(password: str) -> bytes:
    """Normalise un mot de passe en une entree bcrypt de longueur fixe."""
    digest = hashlib.sha256(password.encode("utf-8")).digest()
    return base64.b64encode(digest)

# OAuth2 scheme
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/v1/auth/login")

# Variante tolerante : `auto_error=False` rend None au lieu de lever 401 quand
# l'en-tete Authorization est absent. Utilisee par `get_current_user_optional`.
_oauth2_optionnel = OAuth2PasswordBearer(tokenUrl="/api/v1/auth/login", auto_error=False)

# JWT settings — lus depuis la configuration.
# Auparavant ALGORITHM et ACCESS_TOKEN_EXPIRE_MINUTES etaient codes en dur ici
# (7 jours) alors que config.py declare 30 minutes : les deux valeurs se
# contredisaient et celle du fichier de configuration n'avait aucun effet.
# Le garde-fou hasattr etait vestigial : SECRET_KEY existe toujours.
SECRET_KEY = settings.SECRET_KEY
ALGORITHM = settings.ALGORITHM
ACCESS_TOKEN_EXPIRE_MINUTES = settings.ACCESS_TOKEN_EXPIRE_MINUTES


def hash_password(password: str) -> str:
    """
    Hash a password using bcrypt.

    Args:
        password: Plain text password

    Returns:
        Hashed password
    """
    return bcrypt.hashpw(_prepare(password), bcrypt.gensalt()).decode("utf-8")


def verify_password(plain_password: str, hashed_password: str) -> bool:
    """
    Verify a password against its hash.

    Args:
        plain_password: Plain text password to verify
        hashed_password: Bcrypt hash to verify against

    Returns:
        True if password matches, False otherwise
    """
    # Un compte cree par Google n'a PAS de mot de passe : `hashed_password` est
    # NULL. Sans ce controle, `.encode()` leve un AttributeError — que le
    # `except (ValueError, TypeError)` ci-dessous n'attrape pas — et la simple
    # tentative de connexion par mot de passe sur un compte Google repondait 500.
    if not hashed_password:
        return False

    try:
        return bcrypt.checkpw(_prepare(plain_password), hashed_password.encode("utf-8"))
    except (ValueError, TypeError):
        # Empreinte illisible ou tronquee : on refuse plutot que de propager.
        return False


def duree_de_session(user: User) -> timedelta:
    """
    Duree de vie du jeton, selon le privilege du compte.

    Les valeurs sont lues sur `settings` A L'APPEL et non a l'import : les
    constantes de module ci-dessus sont figees au chargement, et un test qui
    modifierait le reglage ne verrait rien changer.
    """
    minutes = (
        settings.ADMIN_TOKEN_EXPIRE_MINUTES
        if user.is_admin()
        else settings.ACCESS_TOKEN_EXPIRE_MINUTES
    )
    return timedelta(minutes=minutes)


def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
    """
    Create a JWT access token.

    Args:
        data: Data to encode in token (typically {"sub": user_email})
        expires_delta: Optional expiration time delta

    Returns:
        Encoded JWT token
    """
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.now(timezone.utc) + expires_delta
    else:
        expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)

    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt


async def get_current_user(
    token: str = Depends(oauth2_scheme), db: AsyncSession = Depends(get_db)
) -> User:
    """
    Get current authenticated user from JWT token.

    Args:
        token: JWT token from Authorization header
        db: Database session

    Returns:
        Authenticated User object

    Raises:
        HTTPException: If token is invalid or user not found
    """
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )

    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        email: str = payload.get("sub")
        if email is None:
            raise credentials_exception
    except JWTError:
        raise credentials_exception

    # Get user from database
    query = select(User).where(User.email == email)
    result = await db.execute(query)
    user = result.scalar_one_or_none()

    if user is None:
        raise credentials_exception

    if not user.is_active:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN, detail="User account is inactive"
        )

    return user


async def get_current_user_optional(
    token: Optional[str] = Depends(_oauth2_optionnel), db: AsyncSession = Depends(get_db)
) -> Optional[User]:
    """
    L'utilisateur courant, ou None quand la requete est anonyme.

    Existe pour les routes qui doivent servir les deux publics — le chat reste
    utilisable sans compte, mais doit rattacher la conversation quand il y en a
    un.

    LA DISTINCTION QUI COMPTE : pas d'en-tete `Authorization` rend `None` ; un
    en-tete PRESENT mais dont le jeton est invalide ou expire leve 401, jamais
    `None`. Degrader silencieusement en anonyme serait le pire comportement :
    l'utilisateur croirait sa conversation enregistree alors qu'elle partirait
    en `user_id` NULL, invisible dans sa liste. Le front sait deja traiter un
    401 (`apiFetch` : deconnexion puis redirection).
    """
    if token is None:
        return None
    return await get_current_user(token=token, db=db)


async def get_current_active_user(current_user: User = Depends(get_current_user)) -> User:
    """
    Get current active user.

    Args:
        current_user: Current user from token

    Returns:
        Active user

    Raises:
        HTTPException: If user is inactive
    """
    if not current_user.is_active:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Inactive user")
    return current_user


async def get_current_admin_user(current_user: User = Depends(get_current_user)) -> User:
    """
    Get current user with admin role.

    Args:
        current_user: Current user from token

    Returns:
        Admin user

    Raises:
        HTTPException: If user doesn't have admin role
    """
    if not current_user.is_admin():
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Admin access required")
    return current_user


async def get_current_superadmin_user(current_user: User = Depends(get_current_user)) -> User:
    """
    Get current user with superadmin role.

    Args:
        current_user: Current user from token

    Returns:
        Superadmin user

    Raises:
        HTTPException: If user doesn't have superadmin role
    """
    if not current_user.is_superadmin():
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN, detail="Superadmin access required"
        )
    return current_user