आप प्रमाणीकरण (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 को दृष्टिकोण बुझ्न महत्त्वपूर्ण छ: यसले मानक **OAuth2-password-flow-with-JWT** प्याटर्नका लागि निर्माण खण्डहरू (`OAuth2PasswordBearer`, सुरक्षा उपयोगिताहरू) प्रदान गर्छ, जसले FastAPI को शक्तिहरूको सुंदरतापूर्वक लाभ उठाउँछ — एक लगइन अन्तबिन्दु एक हस्ताक्षरित टोकन जारी गर्छ, र एक **`get_current_user` निर्भरता** यसलाई मान्यता गर्छ, कुनै पनि मार्गलाई सफाईसँग सुरक्षित गर्छ जसमा यस पर पनि निर्भर छ (idiomatic FastAPI auth प्याटर्न)।

धेरै पक्षहरू सही गर्न महत्त्वपूर्ण छन्: **पासवर्ड ह्यास गर्ने** (bcrypt, कहिले पनि सादा पाठ नभई, स्थिर-समय प्रमाणीकरणसँग), **JWT हस्ताक्षर र प्रमाणित गर्ने** सही तरिकाले (हस्ताक्षर + समय सीमा मान्यता), **प्रमाणीकरण** (तपाई को हुनुहुन्छ) लाई **प्राधिकरण** (तपाई के गर्न सक्नुहुन्छ, भूमिका/स्कोप जाँच मार्फत) बाट अलग गर्ने, र गोप्य कुञ्जी सुरक्षित राख्ने।

यो प्याटर्न सुरक्षित तरिकाले कसरी लागू गर्ने भनेर जान्ने — टोकन जारी गर्ने, मान्यता गर्ने निर्भरता, र प्राधिकरण — FastAPI अनुप्रयोगहरू निर्माण गर्नको लागि प्रमुख-स्तरीय ज्ञानको आधार छ, किनकि प्रमाणीकरण सर्वव्यापी र अनुचित तरिकाले लागू गरिँदा खतरनाक गल्तीहरूको एक बार-बार स्रोत हो।