Mestre Djangos tillatelsessystem: En omfattende guide til autorisasjon

Innen webutvikling er sikkerhet avgjørende. Django, et kraftig Python-webrammeverk, tilbyr et robust og fleksibelt tillatelsessystem for å administrere brukerautorisasjon og beskytte applikasjonens ressurser. Denne omfattende guiden går i dybden på vanskelighetene i Djangos tillatelsessystem, og tilbyr praktiske eksempler og beste praksiser for å implementere sikker og skalerbar autorisasjon i dine Django-prosjekter.

Forstå autentisering kontra autorisasjon

Før du dykker ned i detaljene i Djangos tillatelsessystem, er det avgjørende å forstå forskjellen mellom autentisering og autorisasjon:

• Autentisering: Bekrefter identiteten til en bruker. Det svarer på spørsmålet "Hvem er du?". Dette håndteres vanligvis gjennom kombinasjoner av brukernavn/passord, sosiale pålogginger eller andre identitetsleverandører.
• Autorisasjon: Bestemmer hva en autentisert bruker har lov til å gjøre. Det svarer på spørsmålet "Hva har du lov til å gjøre?". Det er her Djangos tillatelsessystem kommer inn i bildet.

Autentisering kommer *før* autorisasjon. Du må vite hvem brukeren er før du kan bestemme hva de har lov til å få tilgang til eller endre.

Djangos innebygde tillatelsessystem

Django tilbyr et innebygd tillatelsessystem basert på modeller, brukere og grupper. Det er enkelt å bruke for grunnleggende autorisasjonsbehov, men kan utvides og tilpasses for å håndtere mer komplekse scenarier.

Modelltillatelser

Django oppretter automatisk standardtillatelser for hver modell, slik at du kan kontrollere hvem som kan opprette, lese, oppdatere og slette forekomster av den modellen. Disse tillatelsene er:

• add_[modellnavn]: Tillater oppretting av nye forekomster av modellen.
• change_[modellnavn]: Tillater oppdatering av eksisterende forekomster av modellen.
• delete_[modellnavn]: Tillater sletting av forekomster av modellen.
• view_[modellnavn]: Tillater visning av forekomster av modellen (Django 3.1+).

Hvis du for eksempel har en modell som heter `Article`, vil Django opprette følgende tillatelser:

• `add_article`
• `change_article`
• `delete_article`
• `view_article`

Brukere og grupper

Djangos innebygde autentiseringssystem gir to grunnleggende enheter for å administrere tillatelser:

• Brukere: Individuelle brukerkontoer i applikasjonen din.
• Grupper: Samlinger av brukere med delte tillatelser. Dette er en mer vedlikeholdbar måte å bruke tillatelser på mange brukere samtidig.

Du kan tilordne tillatelser direkte til brukere eller, oftere, tilordne tillatelser til grupper og deretter legge brukere til disse gruppene.

Eksempel: Administrere artikkelstillatelser

La oss si at du har en bloggapplikasjon med en `Article`-modell. Du vil bare tillate at bestemte brukere kan opprette nye artikler, redigere eksisterende artikler og slette artikler. Slik kan du implementere dette ved hjelp av Djangos innebygde tillatelsessystem:

1. Opprett grupper: Opprett grupper som "Editor" og "Author" i Django-administrasjonspanelet.
2. Tilordne tillatelser: Tilordne tillatelsene `add_article`, `change_article` og `delete_article` til "Editor"-gruppen. Tilordne bare `add_article`-tillatelsen til "Author"-gruppen.
3. Legg brukere til grupper: Legg de aktuelle brukerne til "Editor"- og "Author"-gruppene.

Nå vil brukere i "Editor"-gruppen ha full tilgang til å administrere artikler, mens brukere i "Author"-gruppen bare vil kunne opprette nye artikler.

Implementere tillatelser i visninger

Når du har definert tillatelsene dine og tilordnet dem til brukere eller grupper, må du håndheve disse tillatelsene i visningene dine. Django tilbyr flere måter å gjøre dette på:

`permission_required`-dekoratør

`@permission_required`-dekoratøren er en enkel måte å begrense tilgangen til en visning til brukere med spesifikke tillatelser.

            
from django.contrib.auth.decorators import permission_required
from django.shortcuts import render

@permission_required('myapp.add_article')
def create_article(request):
    # Bare brukere med 'myapp.add_article'-tillatelsen kan få tilgang til denne visningen
    return render(request, 'myapp/create_article.html')

            

              
                Copy
              
            
          

Hvis en bruker uten den nødvendige tillatelsen prøver å få tilgang til visningen, vil de bli omdirigert til påloggingssiden eller motta en 403 Forbidden-feil, avhengig av innstillingene dine.

`LoginRequiredMixin` og `PermissionRequiredMixin` (for klassebaserte visninger)

For klassebaserte visninger kan du bruke `LoginRequiredMixin` og `PermissionRequiredMixin` for å håndheve autentisering og autorisasjon:

            
from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin
from django.views.generic import CreateView
from .models import Article

class ArticleCreateView(LoginRequiredMixin, PermissionRequiredMixin, CreateView):
    model = Article
    fields = ['title', 'content']
    permission_required = 'myapp.add_article'
    template_name = 'myapp/article_form.html'

            

              
                Copy
              
            
          

Dette eksemplet demonstrerer hvordan du begrenser tilgangen til `ArticleCreateView` til bare autentiserte brukere med `add_article`-tillatelsen.

Kontrollere tillatelser manuelt

Du kan også sjekke tillatelser manuelt i visningene dine ved hjelp av `has_perm()`-metoden på brukobjektet:

            
from django.shortcuts import render, redirect


def update_article(request, article_id):
    article = Article.objects.get(pk=article_id)

    if request.user.has_perm('myapp.change_article', article):
        # Brukeren har tillatelse til å oppdatere artikkelen
        # Implementer oppdateringslogikk her
        return render(request, 'myapp/update_article.html', {'article': article})
    else:
        # Brukeren har ikke tillatelse
        return render(request, 'myapp/permission_denied.html')

            

              
                Copy
              
            
          

I dette eksemplet sjekker vi om brukeren har `change_article`-tillatelsen for en spesifikk `article`-forekomst. Dette lar deg implementere tillatelser på objektnivå, der tillatelser gis basert på det spesifikke objektet som brukes.

Egendefinerte tillatelser

Djangos innebygde tillatelser er ofte tilstrekkelige for grunnleggende autorisasjonsbehov. I mer komplekse applikasjoner kan det imidlertid være nødvendig å definere egendefinerte tillatelser for å gjenspeile spesifikk forretningslogikk eller tilgangskontrollkrav.

Definere egendefinerte tillatelser i modeller

Du kan definere egendefinerte tillatelser i modellens `Meta`-klasse ved hjelp av `permissions`-alternativet:

            
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)
    published_date = models.DateTimeField(blank=True, null=True)

    class Meta:
        permissions = [
            ('can_publish_article', 'Kan publisere artikkel'),
            ('can_comment_article', 'Kan kommentere artikkel'),
        ]

            

              
                Copy
              
            
          

Dette eksemplet definerer to egendefinerte tillatelser: `can_publish_article` og `can_comment_article`. Disse tillatelsene opprettes automatisk når du kjører `python manage.py migrate`.

Bruke egendefinerte tillatelser

Når du har definert de egendefinerte tillatelsene dine, kan du bruke dem på samme måte som de innebygde tillatelsene, ved hjelp av `@permission_required`-dekoratøren, `PermissionRequiredMixin` eller `has_perm()`-metoden.

            
from django.contrib.auth.decorators import permission_required
from django.shortcuts import render

@permission_required('myapp.can_publish_article')
def publish_article(request, article_id):
    # Bare brukere med 'myapp.can_publish_article'-tillatelsen kan få tilgang til denne visningen
    article = Article.objects.get(pk=article_id)
    article.published_date = timezone.now()
    article.save()
    return render(request, 'myapp/article_published.html', {'article': article})

            

              
                Copy
              
            
          

Tillatelser på objektnivå

Tillatelser på objektnivå lar deg kontrollere tilgangen til spesifikke forekomster av en modell, i stedet for å gi blanketttillatelser for alle forekomster. Dette er viktig for applikasjoner der brukere bare skal kunne få tilgang til eller endre ressurser de eier eller har blitt eksplisitt gitt tilgang til.

Implementere tillatelser på objektnivå

Det er flere måter å implementere tillatelser på objektnivå i Django:

• Kontrollere tillatelser manuelt: Som vist tidligere kan du bruke `has_perm()`-metoden til å sjekke tillatelser for en spesifikk objektforekomst.
• Bruke tredjepartsbiblioteker: Biblioteker som `django-guardian` gir mer strukturerte og gjenbrukbare måter å administrere tillatelser på objektnivå.

Eksempel: Bruke `django-guardian`

`django-guardian` forenkler prosessen med å tilordne og sjekke tillatelser på objektnivå. Her er et grunnleggende eksempel:

1. Installer `django-guardian`: `pip install django-guardian`
2. Konfigurer `settings.py`: Legg til `'guardian'` i `INSTALLED_APPS` og konfigurer de nødvendige autentiseringsbackends.
3. Tilordne tillatelser: Bruk `assign_perm()`-funksjonen til å gi tillatelser til brukere eller grupper for spesifikke objekter.
4. Sjekk tillatelser: Bruk `has_perm()`-funksjonen til å sjekke om en bruker har en spesifikk tillatelse for et spesifikt objekt.

            
from guardian.shortcuts import assign_perm, get_perms

# Tilordne 'change_article'-tillatelsen til en bruker for en spesifikk artikkel
assign_perm('change_article', user, article)

# Sjekk om brukeren har 'change_article'-tillatelsen for artikkelen
if user.has_perm('change_article', article):
    # Brukeren har tillatelse
    pass

            

              
                Copy
              
            
          

`django-guardian` tilbyr også en `PermissionListMixin` for klassebaserte visninger, noe som gjør det enklere å vise en liste over objekter som en bruker har tillatelse til å få tilgang til.

Django REST Framework-tillatelser

Hvis du bygger REST API-er med Django REST Framework, må du bruke tillatelsesklassene for å kontrollere tilgangen til API-endepunktene dine. DRF tilbyr flere innebygde tillatelsesklasser, inkludert:

• `AllowAny`: Tillater ubegrenset tilgang til API-endepunktet.
• `IsAuthenticated`: Krever at brukeren er autentisert for å få tilgang til API-endepunktet.
• `IsAdminUser`: Krever at brukeren er administrator for å få tilgang til API-endepunktet.
• `IsAuthenticatedOrReadOnly`: Tillater skrivebeskyttet tilgang til ikke-autentiserte brukere, men krever autentisering for skrivetilgang.
• `DjangoModelPermissions`: Bruker Djangos standardmodelltillatelser til å kontrollere tilgangen.
• `DjangoObjectPermissions`: Bruker `django-guardian` til å håndheve tillatelser på objektnivå.

Bruke DRF-tillatelsesklasser

Du kan angi tillatelsesklassene for en visning ved hjelp av `permission_classes`-attributtet:

            
from rest_framework import generics
from rest_framework.permissions import IsAuthenticated

class ArticleList(generics.ListCreateAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    permission_classes = [IsAuthenticated]

            

              
                Copy
              
            
          

Dette eksemplet begrenser tilgangen til `ArticleList`-API-endepunktet til bare autentiserte brukere.

Egendefinerte DRF-tillatelser

Du kan også opprette egendefinerte DRF-tillatelsesklasser for å implementere mer kompleks autorisasjonslogikk. En egendefinert tillatelsesklasse bør arve fra `rest_framework.permissions.BasePermission` og overstyre `has_permission()`- og/eller `has_object_permission()`-metodene.

            
from rest_framework import permissions

class IsAuthorOrReadOnly(permissions.BasePermission):
    """
    Egendefinert tillatelse til bare å tillate forfattere av et objekt å redigere det.
    """

    def has_object_permission(self, request, view, obj):
        # Lesetillatelser er tillatt for enhver forespørsel,
        # så vi vil alltid tillate GET-, HEAD- eller OPTIONS-forespørsler.
        if request.method in permissions.SAFE_METHODS:
            return True

        # Forekomsten må ha et attributt som heter `author`.
        return obj.author == request.user

            

              
                Copy
              
            
          

Dette eksemplet definerer en egendefinert tillatelsesklasse som bare tillater forfatteren av en artikkel å redigere den, samtidig som den tillater lesetilgang til alle.

Sikkerhetsmessige beste praksiser

Implementering av et robust tillatelsessystem er avgjørende for å sikre Django-applikasjonen din. Her er noen sikkerhetsmessige beste praksiser du bør huske på:

• Prinsippet om minste privilegium: Gi brukere bare de minste tillatelsene de trenger for å utføre oppgavene sine. Unngå å tilordne unødvendige tillatelser.
• Bruk grupper: Administrer tillatelser gjennom grupper i stedet for å tilordne tillatelser direkte til individuelle brukere. Dette forenkler administrasjonen og reduserer risikoen for feil.
• Regelmessige revisjoner: Gå regelmessig gjennom tillatelsesinnstillingene dine for å sikre at de fortsatt er passende og at ingen uautorisert tilgang er gitt.
• Rens inndata: Rens alltid brukerinndata for å forhindre injeksjonsangrep som kan omgå tillatelsessystemet ditt.
• Test grundig: Test tillatelsessystemet ditt grundig for å sikre at det oppfører seg som forventet og at det ikke finnes noen sårbarheter. Skriv automatiserte tester for å verifisere tillatelseskontroller.
• Hold deg oppdatert: Hold Django-rammeverket og relaterte biblioteker oppdatert for å dra nytte av de nyeste sikkerhetsoppdateringene og feilrettingene.
• Vurder en innholdssikkerhetspolicy (CSP): En CSP kan bidra til å forhindre angrep på tvers av nettsteder (XSS), som kan brukes til å omgå autorisasjonsmekanismer.

Internasjonaliseringshensyn

Når du designer tillatelsessystemet ditt for et globalt publikum, bør du vurdere følgende internasjonaliseringsaspekter:

• Rollenavn: Hvis applikasjonen din bruker roller (f.eks. redaktør, forfatter, moderator), må du sørge for at disse rollenavnene er enkle å oversette og kulturelt passende for alle støttede språk. Vurder å bruke språktspesifikke variasjoner av rollenavn.
• Brukergrensesnitt: Design brukergrensesnittet ditt slik at det er tilpassbart til forskjellige språk og kulturelle konvensjoner. Dette inkluderer dato-/klokkeslettformater, tallformater og tekstretning.
• Tidssoner: Ta høyde for forskjellige tidssoner når du gir eller tilbakekaller tillatelser basert på tidssensitive hendelser. Lagre tidsstempler i UTC og konverter dem til brukerens lokale tidssone for visning.
• Datavernforskrifter: Vær oppmerksom på datavernforskrifter i forskjellige land (f.eks. GDPR i Europa, CCPA i California). Implementer passende samtykkemekanismer og databeskyttelsestiltak.
• Tilgjengelighet: Sørg for at tillatelsessystemet ditt er tilgjengelig for brukere med funksjonshemninger, i samsvar med tilgjengelighetsstandarder som WCAG.

Konklusjon

Djangos tillatelsessystem gir et kraftig og fleksibelt rammeverk for å administrere autorisasjon i webapplikasjonene dine. Ved å forstå de innebygde funksjonene, egendefinerte tillatelsene, tillatelsene på objektnivå og sikkerhetsmessige beste praksiser, kan du bygge sikre og skalerbare applikasjoner som beskytter dine verdifulle ressurser. Husk å tilpasse tillatelsessystemet ditt til de spesifikke behovene til applikasjonen din og å regelmessig gjennomgå og oppdatere innstillingene dine for å sikre at de forblir effektive.

Denne guiden gir en omfattende oversikt over Djangos tillatelsessystem. Etter hvert som du bygger mer komplekse applikasjoner, kan du støte på mer avanserte scenarier. Ikke nøl med å utforske Django-dokumentasjonen og fellesskapsressursene for ytterligere veiledning.