તમે ઑધિકૃતता (OAuth2/JWT) કેવી રીતે અમલમાં મૂકો છો?

Question

Accepted Answer

FastAPI બિલ્ટ-ઇન સાધનો (`OAuth2PasswordBearer`, સુરક્ષા ઉપયોગિતાઓ) પ્રદાન કરે છે ઑધિકૃતતા અમલમાં મૂકવા માટે, સામાન્ય રીતે **OAuth2 પાસવર્ડ ફ્લો સાથે JWT ટોકન** નો ઉપયોગ કરીને. આ પેટર્ન ટોકન જારી કરવું (લૉગઇન) સાથે એક નિર્ભરતા કે જે સુરક્ષિત માર્ગો પર ટોકન માન્યતા આપે તેને જોડે છે.

## લૉગઇન પર પાસવર્ડ હેશ કરવું અને JWT જારી કરવું

```python
from passlib.context import CryptContext
from jose import jwt
from datetime import datetime, timedelta

pwd = CryptContext(schemes=["bcrypt"])    # secure password hashing

@app.post("/login")
def login(form: OAuth2PasswordRequestForm = Depends()):
    user = get_user(form.username)
    if not user or not pwd.verify(form.password, user.hashed_password):  # constant-time check
        raise HTTPException(401, "Invalid credentials")
    # issue a signed JWT containing the user identity + expiry
    token = jwt.encode(
        {"sub": user.username, "exp": datetime.utcnow() + timedelta(minutes=30)},
        SECRET_KEY, algorithm="HS256",
    )
    return {"access_token": token, "token_type": "bearer"}
```

પાસવર્ડ **હેશ** કર્યા હોય છે (bcrypt) — ક્યારેય સાદા ટેક્સ્ટમાં સંગ્રહિત નથી. માન્ય લૉગઇન પર, **JWT** જારી કરવામાં આવે છે: એક હસ્તાક્ષરિત ટોકન જે વપરાશકર્તાની ઓળખ અને સમાપ્તિ ધરાવે છે.

## સુરક્ષિત માર્ગો પર ટોકન માન્યતા આપવી (એક નિર્ભરતા)

```python
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")   # extracts the Bearer token

def get_current_user(token: str = Depends(oauth2_scheme)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])   # verify signature + expiry
        username = payload.get("sub")
    except JWTError:
        raise HTTPException(401, "Invalid token")
    user = get_user(username)
    if not user:
        raise HTTPException(401, "User not found")
    return user

@app.get("/me")
def read_me(user: User = Depends(get_current_user)):     # PROTECTED — requires a valid token
    return user
```

એક `get_current_user` નિર્ભરતા JWT ને કાઢી નાખે છે અને **ચકાસણી** કરે છે (હસ્તાક્ષર + સમાપ્તિ), વપરાશકર્તા ને લોડ કરે છે, અને સુરક્ષિત એન્ડપોઇન્ટમાં ઇનજેક્ટ કરવામાં આવે છે — કોઈપણ માર્ગ તેના પર આશ્રિત છે તેને ઑધિકૃતતાની જરૂર છે.

## અધિકૃતીકરણ (ભૂમિકાઓ/સ્કોપ)

```python
def require_admin(user: User = Depends(get_current_user)):
    if not user.is_admin:
        raise HTTPException(403, "Forbidden")     # authorization check
    return user
# OAuth2 SCOPES provide fine-grained permission control
```

## તે શા માટે મહત્વપૂર્ણ છે

ઑધિકૃતતા આવશ્યક અને **સુરક્ષા-નિર્ણાયક** છે — લગભગ દરેક વાસ્તવિક API ને માર્ગો સુરક્ષિત કરવાની જરૂર છે, અને ઑધિકૃતતા ખોટી રીતે બંધાણ કરવો ગંભીર નિર્બંધતાઓ બનાવે છે.

FastAPI ના આ અભિગમને સમજવું મહત્વપૂર્ણ છે: તે બિલ્ડીંગ બ્લોક્સ (`OAuth2PasswordBearer`, સુરક્ષા ઉપયોગિતાઓ) પ્રદાન કરે છે માનક **OAuth2-પાસવર્ડ-ફ્લો-સાથે-JWT** પેટર્ન માટે, જે ભવ્ય રીતે FastAPI ની શક્તિઓનો લાભ લે છે — એક લૉગઇન એન્ડપોઇન્ટ હસ્તાક્ષરિત ટોકન જારી કરે છે, અને એક **`get_current_user` નિર્ભરતા** તેને માન્યતા આપે છે, સુરક્ષિત રીતે કોઈપણ માર્ગને સુરક્ષિત કરીને તે તેના પર આશ્રિત છે (આદર્શ FastAPI ઑધિકૃતતા પેટર્ન).

ઘણીબધ બાબતો યોગ્ય રીતે મેળવવી ગંભીર છે: **હેશીંગ પાસવર્ડ** (bcrypt, ક્યારેય સાદા ટેક્સ્ટ નથી, સતત-સમય ચકાસણી સાથે), **JWT હસ્તાક્ષર અને ચકાસણી** યોગ્ય રીતે (હસ્તાક્ષર + સમાપ્તિ માન્યતા), **ઑધિકૃતતા** (તમે કોણ છો) સાથે વિચ્છેદન કરવું અને **અધિકૃતીકરણ** (તમે શું કરી શકો છો, ભૂમિકા/સ્કોપ તપાસ દ્વારા), અને ગુપ્ત કી સુરક્ષિત રાખવી.

જાણવું કે આ પેટર્નને સુરક્ષિત રીતે કેવી રીતે અમલમાં મૂકવું — ટોકન જારી કરવું, માન્યતા નિર્ભરતા, અને અધિકૃતીકરણ — સુરક્ષિત FastAPI એપ્લિકેશનો બનાવવા માટે મૌલિક વરિષ્ઠ-સ્તરીય જ્ઞાન છે, કારણ કે ઑધિકૃતતા સર્વત્ર અને ખોટી રીતે અમલમાં મૂકવાય તો ખતરનાક ભૂલોનું વારંવાર સ્ત્રોત છે.