Django inkluderer et komplet, indbygget autentificeringssystem (django.contrib.auth), der håndterer brugere, adgangskoder, sessioner/login og tilladelser — endnu en "batteries-included"-funktion, der sparer dig for at bygge (og få forkert) denne sikkerhedskritiske funktionalitet.
from django.contrib.auth.models import User
# passwords are HASHED automatically — never store plaintext
user = User.objects.create_user(username="ann", email="[email protected]", password="secret")
user.set_password("newpassword") # always use set_password (it hashes)
user.check_password("secret") # verify a password (constant-time)
Den indbyggede User-model håndterer sikker adgangskodehashing automatisk (ved hjælp af stærke algoritmer som PBKDF2) — du gemmer eller sammenligner aldrig adgangskoder i klartekst, hvilket eliminerer en stor sikkerhedsrisiko.
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() verificerer legitimationsoplysninger, og login() etablerer en session — efter hvilken request.user er den loggede bruger på hver anmodning (via authentication middleware).
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): ...
# 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 skelner mellem autentificering (hvem du er — login) og autorisering (hvad du kan gøre — tilladelser). Det leverer tilladelser per model (add/change/delete/view), grupper til rollebaseret adgang og decorators/mixins til at håndhæve dem.
✓ 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
Djangos indbyggede autentificeringssystem er en stor, sikkerhedskritisk funktion, der sparer dig for at bygge en af de mest fejlbetingede og farlige dele af en webapplikation selv.
At forstå det er væsentligt, fordi næsten hver virkelige applikation har brug for brugerkonti, login og adgangskontrol — og at få autentificering forkert skaber alvorlige sikkerhedssårbarheder (adgangskoder i klartekst, svag hashing, sessionsfejl).
Djangos system håndterer disse korrekt ud af boksen: det hasher adgangskoder sikkert (stærke algoritmer, aldrig klartekst — du bruger create_user/set_password/check_password i stedet for at håndtere adgangskoder manuelt), administrerer sessioner og login (authenticate/login, med request.user tilgængelig overalt via middleware) og leverer autorisering gennem et komplet tilladelser og grupper system.
At vide, hvordan du opretter og autentificerer brugere, beskytter views (@login_required, LoginRequiredMixin) og håndhæver autorisering via tilladelser og grupper (skelnen mellem autentificering — hvem du er — og autorisering — hvad du må gøre) er grundlæggende for at bygge sikre applikationer.
Systemets udvidelsesmuligheder — især ved brug af en custom user-model (kraftigt anbefalet fra projektets start) til at tilføje felter og custom backends til email/OAuth-login — er vigtig praktisk viden.
Fordi autentificering er både allestedsstede og sikkerhedskritisk, og fordi Django leverer en robust, korrekt, batteries-included-løsning, er det at mestre sit auth-system kernebetinget viden, der lader dig bygge sikre brugervendte applikationer uden at genopfinde (og risikere) denne grundlæggende funktionalitet.