आप authentication (OAuth2/JWT) कैसे लागू करते हैं?

Question

Accepted Answer

FastAPI authentication लागू करने के लिए built-in tools (`OAuth2PasswordBearer`, security utilities) प्रदान करता है, जो आमतौर पर **JWT tokens के साथ OAuth2 password flow** का उपयोग करता है। यह pattern token issuance (login) को एक ऐसी dependency के साथ जोड़ता है जो protected routes पर token को validate करती है।

## passwords को hash करना और login पर 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"}
```

Passwords को **hash** किया जाता है (bcrypt) — कभी plaintext में store नहीं किया जाता। वैध login पर, एक **JWT** जारी किया जाता है: एक signed token जो उपयोगकर्ता की identity और एक expiry रखता है।

## protected routes पर token को validate करना (एक dependency)

```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` dependency JWT को extract और **verify** करती है (signature + expiry), उपयोगकर्ता को load करती है, और protected endpoints में inject की जाती है — इस पर निर्भर कोई भी route authentication की आवश्यकता रखता है।

## Authorization (roles/scopes)

```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
```

## यह क्यों महत्वपूर्ण है

Authentication आवश्यक और **security-critical** है — लगभग हर वास्तविक API को routes की रक्षा करने की आवश्यकता होती है, और auth को गलत करना गंभीर vulnerabilities पैदा करता है।

FastAPI के दृष्टिकोण को समझना महत्वपूर्ण है: यह मानक **OAuth2-password-flow-with-JWT** pattern के लिए building blocks (`OAuth2PasswordBearer`, security utilities) प्रदान करता है, जो FastAPI की ताकतों का सुरुचिपूर्ण लाभ उठाता है — एक login endpoint एक signed token जारी करता है, और एक **`get_current_user` dependency** इसे validate करती है, साफ-सुथरे ढंग से उस पर निर्भर किसी भी route की रक्षा करती है (idiomatic FastAPI auth pattern)।

कई पहलुओं को सही करना महत्वपूर्ण है: **passwords को hash करना** (bcrypt, कभी plaintext नहीं, constant-time verification के साथ), **JWTs को signing और verifying** सही ढंग से (signature + expiry validation), **authentication** (आप कौन हैं) को **authorization** (आप क्या कर सकते हैं, role/scope checks के माध्यम से) से अलग करना, और secret key को सुरक्षित रखना।

इस pattern को सुरक्षित रूप से लागू करना जानना — token issuance, validation dependency, और authorization — सुरक्षित FastAPI applications बनाने के लिए मौलिक senior-level ज्ञान है, क्योंकि auth सर्वव्यापी है और गलत तरीके से लागू किए जाने पर खतरनाक गलतियों का बार-बार स्रोत है।