మీరు ప్రామాణీకరణను (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-password-flow-with-JWT** నమూనాకు అందిస్తుంది, ఇది చక్కగా FastAPI యొక్క బలాలను లాభదాయకంగా ఉపయోగిస్తుంది — లాగిన్ ఎండ్‌పాయింట్ సంతకం చేసిన టోకెన్‌ను జారీ చేస్తుంది, మరియు **`get_current_user` ఆధారపడటం** దానిని ధృవీకరిస్తుంది, చక్కగా దానిపై ఆధారపడే ఏదైనా రూట్‌ను రక్షిస్తుంది (విषయీకరణీయ FastAPI ప్రామాణీకరణ నమూనా).

సంభవించిన అనేక అంశాలు సరిగా పొందటానికి కీలకమైనవి: **పాస్‌వర్డ్‌లను హ్యాష్ చేయడం** (bcrypt, ఎన్నడూ సాధారణ టెక్స్ట్ కాదు, స్థిర-సమయ ధృవీకరణతో), **JWTs ను సరిగా సంతకం చేయడం మరియు నిర్ధారించడం** (సంతకం + సమయ సీమ ధృవీకరణ), **ప్రామాణీకరణ** (మీరు ఎవరు) రాలు/స్కోప్ చెక్‌ల ద్వారా **అధికారం** (మీరు ఏమి చేయవచ్చు) నుండి వేరు చేయడం, మరియు రహస్య కీని సురక్షితంగా ఉంచడం.

ఈ నమూనాను సురక్షితంగా అమలు చేయడం చేతనం — టోకెన్ జారీ చేయడం, ధృవీకరణ ఆధారపడటం, మరియు అధికారం — సురక్షిత FastAPI అనువర్తనాలను నిర్మించడానికి ప్రాథమిక సీనియర్-స్థాయి జ్ఞానం, ఎందుకంటే ప్రామాణీకరణ సర్వ వ్యాప్త మరియు తప్పుగా అమలు చేసినప్పుడు ప్రమాదకరమైన లోపాల యొక్క ఆకస్మిక మూలం.