آپ authentication (OAuth2/JWT) کو کیسے implement کرتے ہیں؟

Question

Accepted Answer

FastAPI built-in tools فراہم کرتا ہے (`OAuth2PasswordBearer`, security utilities) authentication implement کرنے کے لیے، عام طور پر **OAuth2 password flow with JWT tokens** استعمال کرتے ہوئے۔ یہ pattern token issuance (login) کو ایک dependency کے ساتھ جوڑتا ہے جو protected routes پر token کی تصدیق کرتا ہے۔

## Login پر passwords کو hash کرنا اور 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 نہیں کیے جاتے۔ Valid login پر، ایک **JWT** جاری کیا جاتا ہے: ایک signed token جو user کی identity اور expiry رکھتا ہے۔

## Protected routes پر token کی تصدیق (ایک 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)، user کو 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** — تقریباً ہر real API کو routes کو محفوظ رکھنے کی ضرورت ہے، اور غلط auth سنگین vulnerabilities پیدا کرتا ہے۔

FastAPI کے approach کو سمجھنا اہم ہے: یہ building blocks فراہم کرتا ہے (`OAuth2PasswordBearer`, security utilities) standard **OAuth2-password-flow-with-JWT** pattern کے لیے، جو elegantly FastAPI کی طاقت کا فائدہ اٹھاتا ہے — ایک login endpoint ایک signed token جاری کرتا ہے، اور ایک **`get_current_user` dependency`** اسے validate کرتا ہے، cleanly کسی بھی route کو محفوظ رکھتے ہوئے جو اس پر منحصر ہے (idiomatic FastAPI auth pattern)۔

کئی aspects صحیح طریقے سے حاصل کرنا ضروری ہیں: **passwords کو hash کرنا** (bcrypt، کبھی plaintext نہیں، constant-time verification کے ساتھ)، **JWTs کو صحیح طریقے سے sign اور verify کرنا** (signature + expiry validation)، **authentication** (آپ کون ہیں) کو **authorization** (آپ کیا کر سکتے ہیں، role/scope checks کے ذریعے) سے الگ کرنا، اور secret key کو محفوظ رکھنا۔

یہ جاننا کہ اس pattern کو محفوظ طریقے سے کیسے implement کریں — token issuance، validation dependency، اور authorization — secure FastAPI applications بنانے کے لیے fundamental senior-level knowledge ہے، کیونکہ auth both ubiquitous ہے اور غلط طریقے سے implement کیے جانے پر خطرناک غلطیوں کا ایک بار بار source ہے۔