როგორ მუშაობს Django-ს ავტენტიკაციის სისტემა?

Question

Accepted Answer

Django შეიცავს სრულ, ჩამონტაჟებულ **ავტენტიკაციის სისტემას** (`django.contrib.auth`), რომელიც სამართავს **მომხმარებლებს**, **პაროლებს**, **სესიებს/ლოგინს** და **უფლებებს** — კიდევ ერთი "ბატარეა-შენიერი" ფიჩა, რომელიც შენ გიშორებს აუცილებელი (და საფრთხის ქვეშ) ამ უსაფრთხოების კრიტიკული ფუნქციონალობის აგებას.

## User მოდელი და მომხმარებლების შექმნა

```python
from django.contrib.auth.models import User

# passwords are HASHED automatically — never store plaintext
user = User.objects.create_user(username="ann", email="a@x.com", password="secret")
user.set_password("newpassword")        # always use set_password (it hashes)
user.check_password("secret")            # verify a password (constant-time)
```

ჩამონტაჟებული `User` მოდელი სამართავს დაშიფრული **პაროლის ჰეშირება** ავტომატურად (ძლიერი ალგორითმების გამოყენებით, როგორიცაა PBKDF2) — თქვენ არასოდეს ინახავთ ან ადარებთ უბრალო ტექსტის პაროლებს, აზღვრებთ ძირითად უსაფრთხოების რისკს.

## ავტენტიკაცია და ლოგინი

```python
from django.contrib.auth import authenticate, login, logout

def login_view(request):
    user = authenticate(request, username=username, password=password)  # verify credentials
    if user is not None:
        login(request, user)             # establish a SESSION (sets request.user)
        return redirect("home")
    # else: invalid credentials

def logout_view(request):
    logout(request)                       # clear the session
```

`authenticate()` ამოწმებს სამidentификacio მონაცემებს, და `login()` ამყარებს სესიას — რის შემდეგ `request.user` არის ლოგინი მოქმედი მომხმარებელი ყოველ მოთხოვნაზე (ავტენტიკაციის middleware-ის გავლით).

## views-ის დაცვა (ლოგინის მოთხოვნა)

```python
from django.contrib.auth.decorators import login_required

@login_required                          # redirect to login if not authenticated
def dashboard(request):
    return render(request, "dashboard.html", {"user": request.user})

# for class-based views:
from django.contrib.auth.mixins import LoginRequiredMixin
class DashboardView(LoginRequiredMixin, ListView): ...
```

## უფლებები და ავტორიზაცია

```python
# checking permissions
request.user.is_authenticated            # is someone logged in?
request.user.is_staff / is_superuser     # role flags
request.user.has_perm("blog.add_article")# a specific permission
request.user.groups.all()                 # group membership (role-based access)

@permission_required("blog.add_article")
def create_article(request): ...
```

Django განასხვავებს **ავტენტიკაციას** (ვინ ხარ — ლოგინი) **ავტორიზაციიდან** (რა შეგიძლია გააკეთო — უფლებები). იგი უზრუნველყოფს მოდელზე თითოეულ უფლებებს (დამატება/შეცვლა/წაშლა/ნახვა), ჯგუფებს როლზე ორიენტირებული წვდომისთვის, და დეკორატორები/mixins აღმოსახულების გამოქ ყოფისთვის.

## ჩამონტაჟებული ავტ-ის views-ები და კასტომიზაცია

```text
✓ Ready-made views/URLs for login, logout, password change/reset (django.contrib.auth.urls)
✓ Customizable: a CUSTOM USER MODEL (recommended from the start) to add fields,
  custom backends (e.g. authenticate via email or OAuth), password validators
```

## რატომ მნიშვნელოვანია

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

ამის გაგება აუცილებელია, რადგან თითქმის ყველა რეალური აპლიკაცია მოითხოვს მომხმარებლის ანგარიშებს, ლოგინს და წვდომის კონტროლს — და ავტენტიკაციის **ცდება იყო სერიოზული უსაფრთხოების სიმ** (უბრალო ტექსტის პაროლი, სუსტი ჰეშირება, სესიის ხარვეზი).

Django-ს სისტემა სამართავს ამ სწორი გზით საკვანძოდ: იგი **ჰეშირებს პაროლებს დაშიფრული** (ძლიერი ალგორითმი, არასოდეს უბრალო ტექსტი — თქვენ ვიყენებთ `create_user`/`set_password`/`check_password` ნაცვლად პაროლების ხელით სამართავისა), ამართებს სესიებს და ლოგინს (`authenticate`/`login`, `request.user` ხელმისაწვდომი ყველგან middleware-ის გავლით), და უზრუნველყოფს ავტორიზაციას ღრმა **უფლებებისა და ჯგუფების სისტემის** მეშვეობით.

მომხმარებლებისა და ავტენტიკაციის შექმნის, views-ის დაცვის (`@login_required`, `LoginRequiredMixin`), და **ავტორიზაციის** გამოქ ყოფის ცოდნა უფლებებისა და ჯგუფების მეშვეობით (განასხვავებს ავტენტიკაციას — ვინ ხარ — ავტორიზაციისგან — რა გაქვს ნებართვა გააკეთო) არის ფუნდამენტური უსაფრთხო აპლიკაციების აგებისთვის.

სისტემის სტაბილურობა — განსაკუთრებით **კასტომური მომხმარებელი მოდელის** (შიგნით რეკომენდირებული პროექტის დაწყებიდან) გამოყენება ველების დამატებისთვის, და კასტომური backends ელ-ფოსტა/OAuth ლოგინისთვის — არის მნიშვნელოვანი პრაქტიკული ცოდნა.

მას შემდეგ, რაც ავტენტიკაცია არის ორივე ჯერ-პოპულარული და უსაფრთხოების კრიტიკული, და რადგან Django უზრუნველყოფს მუდმივი, სწორი, ბატარეა-შენიერი გამოსავალი, სტაფის ავტ-ის სისტემის დაუფლება არის ძირითადი ცოდნა, რომელიც გაძლევს უსაფრთხო მომხმარებელმდელი აპლიკაციების აგების უნარს ამ საფუძველი ფუნქციონალობის ხელახლა გამონახვის (და რისკის) გარეშე.