Django નો authentication system કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

Django માં એક સંપૂર્ણ, બિલ્ટ-ઇન **authentication system** (`django.contrib.auth`) છે જે **users**, **passwords**, **sessions/login**, અને **permissions** હેન્ડલ કરે છે — આ બીજું "batteries-included" ફીચર છે જે તમને આ સુરક્ષા-વિશેષ functionality બિલ્ડ કરવાથી અને ખોટું કરવાથી બચાવે છે।

## User model અને users બનાવવું

```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` model સુરક્ષિત **password hashing** આપમેળે હેન્ડલ કરે છે (PBKDF2 જેવા મજબૂત algorithms વાપરીને) — તમે ક્યારેય plaintext passwords સ્ટોર અથવા તુલના કરતા નથી, જે મુખ્ય સુરક્ષા જોખમ ને દૂર કરે છે।

## Authenticating અને logging in

```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()` credentials ને verify કરે છે, અને `login()` session સ્થાપિત કરે છે — જે પછી `request.user` એ દરેક request પર logged-in user છે (authentication middleware દ્વારા)।

## Views ને સુરક્ષિત કરવું (login આવશ્યક)

```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): ...
```

## Permissions અને authorization

```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 **authentication** (તમે કોણ છો — login) ને **authorization** (તમે શું કરી શકો છો — permissions) થી અલગ કરે છે। તે per-model permissions (add/change/delete/view), role-based access માટે groups, અને તેમને enforce કરવા માટે decorators/mixins પ્રદાન કરે છે।

## બિલ્ટ-ઇન auth views અને customization

```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 નો બિલ્ટ-ઇન authentication system એક મુખ્ય, સુરક્ષા-વિશેષ ફીચર છે જે તમને web application ના સૌથી error-prone અને ખતરનાક ભાગોમાંથી એક બનાવતાં બચાવે છે।

તેને સમજવું આવશ્યક છે કારણ કે લગભગ દરેક વાસ્તવિક application ને user accounts, login, અને access control ની જરૂર છે — અને authentication ને ખોટું કરવું **સંગીન સુરક્ષા vulnerabilities** બનાવે છે (plaintext passwords, નબળું hashing, session flaws)।

Django નો system આ બધું સાચી રીતે હેન્ડલ કરે છે: તે **passwords ને સુરક્ષિત રીતે હેશ કરે છે** (મજબૂત algorithms, ક્યારેય plaintext નહીં — તમે passwords ને manually હેન્ડલ કરવાને બદલે `create_user`/`set_password`/`check_password` વાપરો છો), sessions અને login ને manage કરે છે (`authenticate`/`login`, `request.user` middleware દ્વારા હરજાગી ઉપલબ્ધ છે), અને authorization ને સંપૂર્ણ **permissions અને groups system** દ્વારા પ્રદાન કરે છે।

જાણવું કે કેવી રીતે users બનાવવા અને authenticate કરવા, views ને સુરક્ષિત કરવા (`@login_required`, `LoginRequiredMixin`), અને permissions અને groups દ્વારા **authorization** enforce કરવું (authentication — તમે કોણ છો — ને authorization — તમે શું કરવા માટે પણ છો — થી અલગ કરીને) સુરક્ષિત applications બિલ્ડ કરવા માટે મૌલિક છે।

System ની extensibility — ખાસ કરીને **custom user model** (project ના શરૂઆતથી જ દૃઢપણે ભલામણ કરવામાં આવે છે) વાપરીને fields ઉમેરવા માટે, અને email/OAuth login માટે custom backends — મહત્વપૂર્ણ પ્રાયોગિક જ્ઞાન છે।

કારણ કે authentication બંને વ્યાપક અને સુરક્ષા-વિશેષ છે, અને કારણ કે Django એક મજબૂત, સાચું, batteries-included solution પ્રદાન કરે છે, તેનું auth system ને માસ્ટર કરવું મૂળ જ્ઞાન છે જે તમને આ મૌલિક functionality ને reinvent (અને જોખમમાં) કર્યા વિના સુરક્ષિત user-facing applications બિલ્ડ કરવા દે છે।