ਤੁਸੀਂ ਪ੍ਰਮਾਣਕਤਾ (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, ਕਦੇ ਵੀ ਪਲੇਨਟੈਕਸਟ ਨਹੀਂ, ਸਮੇਂ-ਮੋਟਾ ਪ੍ਰਮਾਣ ਦੇ ਨਾਲ), **JWTs ਨੂੰ ਸਾਈਨ ਕਰਨਾ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ** ਸਹੀ ਤਰੀਕੇ ਨਾਲ (ਸਾਈਨੇਚਰ + ਖਤਮ ਹੋਣ ਦਾ ਸਮਾਂ ਪ੍ਰਮਾਣ), **ਪ੍ਰਮਾਣਕਤਾ** (ਤੁਸੀਂ ਕੌਣ ਹੋ) ਨੂੰ **ਅਧਿਕਾਰ** (ਤੁਸੀਂ ਕੀ ਕਰ ਸਕਦੇ ਹੋ, ਭੂਮਿਕਾ/ਸਕੋਪ ਚੈੱਕ ਦੇ ਵਿਆ) ਤੋਂ ਵੱਖ ਕਰਨਾ, ਅਤੇ ਸੀਕ੍ਰਿਟ ਕੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣਾ।

ਇਸ ਪੈਟਰਨ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਲਾਗੂ ਕਰਨਾ ਜਾਣਨਾ — ਟੋਕਨ ਜਾਰੀ ਕਰਨਾ, ਪ੍ਰਮਾਣ ਨਿਰਭਰਤਾ, ਅਤੇ ਅਧਿਕਾਰ — FastAPI ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ ਬੁਨਿਆਦੀ ਸੀਨੀਅਰ-ਲੈਵਲ ਗਿਆਨ ਹੈ, ਕਿਉਂਕਿ ਪ੍ਰਮਾਣਕਤਾ ਸਰਵ-ਵਿਆਪੀ ਅਤੇ ਗਲਤ ਢੰਗ ਨਾਲ ਲਾਗੂ ਕੀਤੇ ਜਾਣ ਸਮੇਂ ਖਤਰਨਾਕ ਗਲਤੀਆਂ ਦਾ ਇੱਕ ਅਕਸਰ ਸ਼ਵਗਿਤ ਉਪਜ ਹੈ।