როგორ ახორციელებთ აутენტიფიკაციას (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, არ უნდა ინახება ნედლი ტექსტი, მუდმივი დროის ვერიფიკაციით), **JWT-ის ხელმოწერა და ვერიფიკაცია** სწორად (ხელმოწერა + ვადის გასვლის ვალიდაცია), **აუტენტიფიკაციის** განსხვავება (ის ვინ ხართ) **ავტორიზაციიდან** (რა გააკეთებთ, როლის/ფარის შემოწმების მეშვეობით), და საიდუმლო გასაღების დაცვა.

ესე ნიმუშის უსაფრთხოდ განხორციელების ხერხის ცოდნა — ტოკენის გამოშვება, ვალიდაციის დამოკიდებულება და ავტორიზაცია — ფუნდამენტური უფროსი დონის ცოდნა უსაფრთხო FastAPI პროგრამების მშენებლობის სახელმძღვანელოდ, რადგან აუტენტიფიკაცია ყველგან არის დაფაზიანებული და შესაფერი უბედური შედეგის ხშირი წყარო არასწორი განხორციელების შემთხვევაში.