Het Django-permissiesysteem beheersen: een uitgebreide gids voor autorisatie

In de wereld van webontwikkeling is beveiliging van het grootste belang. Django, een krachtig Python-webframework, biedt een robuust en flexibel permissiesysteem om gebruikersautorisatie te beheren en de resources van uw applicatie te beschermen. Deze uitgebreide gids duikt in de complexiteit van Django's permissiesysteem en biedt praktische voorbeelden en best practices voor het implementeren van veilige en schaalbare autorisatie in uw Django-projecten.

Authenticatie versus autorisatie begrijpen

Voordat u in de details van Django's permissiesysteem duikt, is het cruciaal om het verschil te begrijpen tussen authenticatie en autorisatie:

• Authenticatie: Verifieert de identiteit van een gebruiker. Het beantwoordt de vraag "Wie ben je?". Dit wordt doorgaans afgehandeld via gebruikersnaam/wachtwoord-combinaties, sociale logins of andere identiteitsproviders.
• Autorisatie: Bepaalt wat een geauthenticeerde gebruiker mag doen. Het beantwoordt de vraag "Wat mag je doen?". Hier komt Django's permissiesysteem om de hoek kijken.

Authenticatie komt *vóór* autorisatie. U moet weten wie de gebruiker is voordat u kunt bepalen wat ze mogen openen of wijzigen.

Django's ingebouwde permissiesysteem

Django biedt een ingebouwd permissiesysteem op basis van modellen, gebruikers en groepen. Het is eenvoudig te gebruiken voor basis autoratiebehoeften, maar kan worden uitgebreid en aangepast om complexere scenario's af te handelen.

Modelpermissies

Django maakt automatisch standaard permissies voor elk model aan, waarmee u kunt bepalen wie instanties van dat model kan aanmaken, lezen, bijwerken en verwijderen. Deze permissies zijn:

• add_[modelnaam]: Maakt het aanmaken van nieuwe instanties van het model mogelijk.
• change_[modelnaam]: Maakt het bijwerken van bestaande instanties van het model mogelijk.
• delete_[modelnaam]: Maakt het verwijderen van instanties van het model mogelijk.
• view_[modelnaam]: Maakt het bekijken van instanties van het model mogelijk (Django 3.1+).

Als u bijvoorbeeld een model met de naam `Artikel` heeft, maakt Django de volgende permissies aan:

• `add_artikel`
• `change_artikel`
• `delete_artikel`
• `view_artikel`

Gebruikers en groepen

Django's ingebouwde authenticatiesysteem biedt twee fundamentele entiteiten voor het beheren van permissies:

• Gebruikers: Individuele gebruikersaccounts binnen uw applicatie.
• Groepen: Verzamelingen van gebruikers met gedeelde permissies. Dit is een beter beheersbare manier om permissies tegelijkertijd op veel gebruikers toe te passen.

U kunt permissies rechtstreeks aan gebruikers toewijzen of, vaker, permissies toewijzen aan groepen en vervolgens gebruikers aan die groepen toevoegen.

Voorbeeld: Artikelpermissies beheren

Stel dat u een blogapplicatie heeft met een `Artikel`-model. U wilt dat alleen specifieke gebruikers nieuwe artikelen kunnen aanmaken, bestaande artikelen kunnen bewerken en artikelen kunnen verwijderen. Zo kunt u dit implementeren met Django's ingebouwde permissiesysteem:

1. Groepen aanmaken: Maak groepen zoals "Redacteur" en "Auteur" aan in het Django-adminpaneel.
2. Permissies toewijzen: Wijs de permissies `add_artikel`, `change_artikel` en `delete_artikel` toe aan de groep "Redacteur". Wijs alleen de permissie `add_artikel` toe aan de groep "Auteur".
3. Gebruikers aan groepen toevoegen: Voeg de juiste gebruikers toe aan de groepen "Redacteur" en "Auteur".

Nu hebben gebruikers in de groep "Redacteur" volledige toegang om artikelen te beheren, terwijl gebruikers in de groep "Auteur" alleen nieuwe artikelen kunnen aanmaken.

Permissies implementeren in views

Zodra u uw permissies hebt gedefinieerd en ze hebt toegewezen aan gebruikers of groepen, moet u die permissies afdwingen in uw views. Django biedt verschillende manieren om dit te doen:

`permission_required` Decorator

De `@permission_required`-decorator is een eenvoudige manier om de toegang tot een view te beperken tot gebruikers met specifieke permissies.

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

@permission_required('myapp.add_article')
def create_article(request):
    # Alleen gebruikers met de permissie 'myapp.add_article' kunnen deze view benaderen
    return render(request, 'myapp/create_article.html')

            

              
                Copy
              
            
          

Als een gebruiker zonder de vereiste permissie probeert de view te openen, wordt deze omgeleid naar de inlogpagina of krijgt een 403 Forbidden-foutmelding, afhankelijk van uw instellingen.

`LoginRequiredMixin` en `PermissionRequiredMixin` (voor class-based views)

Voor class-based views kunt u de `LoginRequiredMixin` en `PermissionRequiredMixin` gebruiken om authenticatie en autorisatie af te dwingen:

            
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
              
            
          

Dit voorbeeld laat zien hoe u de toegang tot de `ArticleCreateView` kunt beperken tot alleen geauthenticeerde gebruikers met de permissie `add_article`.

Permissies handmatig controleren

U kunt permissies ook handmatig binnen uw views controleren met behulp van de methode `has_perm()` op het userobject:

            
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):
        # Gebruiker heeft toestemming om het artikel bij te werken
        # Implementeer update logica hier
        return render(request, 'myapp/update_article.html', {'article': article})
    else:
        # Gebruiker heeft geen toestemming
        return render(request, 'myapp/permission_denied.html')

            

              
                Copy
              
            
          

In dit voorbeeld controleren we of de gebruiker de permissie `change_article` heeft voor een specifieke `artikel`-instantie. Hiermee kunt u permissies op objectniveau implementeren, waarbij permissies worden verleend op basis van het specifieke object dat wordt benaderd.

Aangepaste permissies

Django's ingebouwde permissies zijn vaak voldoende voor basis autoratiebehoeften. In complexere applicaties moet u echter mogelijk aangepaste permissies definiëren om specifieke bedrijfslogica of toegangscontrolevereisten weer te geven.

Aangepaste permissies definiëren in modellen

U kunt aangepaste permissies definiëren binnen de `Meta`-klasse van uw model met behulp van de optie `permissions`:

            
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 artikel publiceren'),
            ('can_comment_article', 'Kan commentaar op artikel plaatsen'),
        ]

            

              
                Copy
              
            
          

Dit voorbeeld definieert twee aangepaste permissies: `can_publish_article` en `can_comment_article`. Deze permissies worden automatisch aangemaakt wanneer u `python manage.py migrate` uitvoert.

Aangepaste permissies gebruiken

Zodra u uw aangepaste permissies hebt gedefinieerd, kunt u ze op dezelfde manier gebruiken als de ingebouwde permissies, met behulp van de `@permission_required`-decorator, `PermissionRequiredMixin` of de methode `has_perm()`.

            
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):
    # Alleen gebruikers met de permissie 'myapp.can_publish_article' kunnen deze view benaderen
    article = Article.objects.get(pk=article_id)
    article.published_date = timezone.now()
    article.save()
    return render(request, 'myapp/article_published.html', {'article': article})

            

              
                Copy
              
            
          

Object-level permissies

Object-level permissies stellen u in staat om de toegang tot specifieke instanties van een model te beheren, in plaats van algemene permissies voor alle instanties te verlenen. Dit is essentieel voor applicaties waar gebruikers alleen toegang moeten hebben tot of bronnen moeten wijzigen die ze bezitten of waarvoor ze expliciet toegang hebben gekregen.

Object-level permissies implementeren

Er zijn verschillende manieren om object-level permissies in Django te implementeren:

• Permissies handmatig controleren: Zoals eerder getoond, kunt u de methode `has_perm()` gebruiken om permissies voor een specifieke objectinstantie te controleren.
• Gebruik maken van bibliotheken van derden: Bibliotheken zoals `django-guardian` bieden meer gestructureerde en herbruikbare manieren om permissies op objectniveau te beheren.

Voorbeeld: `django-guardian` gebruiken

`django-guardian` vereenvoudigt het proces van het toewijzen en controleren van object-level permissies. Hier is een eenvoudig voorbeeld:

1. Installeer `django-guardian`: `pip install django-guardian`
2. Configureer `settings.py`: Voeg `'guardian'` toe aan uw `INSTALLED_APPS` en configureer de benodigde authenticatiebackends.
3. Permissies toewijzen: Gebruik de functie `assign_perm()` om permissies toe te kennen aan gebruikers of groepen voor specifieke objecten.
4. Permissies controleren: Gebruik de functie `has_perm()` om te controleren of een gebruiker een specifieke permissie heeft voor een specifiek object.

            
from guardian.shortcuts import assign_perm, get_perms

# Wijs de permissie 'change_article' toe aan een gebruiker voor een specifiek artikel
assign_perm('change_article', user, article)

# Controleer of de gebruiker de permissie 'change_article' heeft voor het artikel
if user.has_perm('change_article', article):
    # Gebruiker heeft permissie
    pass

            

              
                Copy
              
            
          

`django-guardian` biedt ook een `PermissionListMixin` voor class-based views, waardoor het gemakkelijker wordt om een lijst met objecten weer te geven waartoe een gebruiker toegang heeft.

Django REST Framework-permissies

Als u REST API's bouwt met Django REST Framework, moet u de permissieklassen gebruiken om de toegang tot uw API-eindpunten te regelen. DRF biedt verschillende ingebouwde permissieklassen, waaronder:

• `AllowAny`: Staat onbeperkte toegang tot het API-eindpunt toe.
• `IsAuthenticated`: Vereist dat de gebruiker is geauthenticeerd om toegang te krijgen tot het API-eindpunt.
• `IsAdminUser`: Vereist dat de gebruiker een beheerder is om toegang te krijgen tot het API-eindpunt.
• `IsAuthenticatedOrReadOnly`: Staat alleen-lezen toegang toe aan niet-geauthenticeerde gebruikers, maar vereist authenticatie voor schrijftoegang.
• `DjangoModelPermissions`: Gebruikt Django's standaard modelpermissies om de toegang te regelen.
• `DjangoObjectPermissions`: Gebruikt `django-guardian` om permissies op objectniveau af te dwingen.

DRF-permissieklassen gebruiken

U kunt de permissieklassen voor een view instellen met behulp van het kenmerk `permission_classes`:

            
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
              
            
          

Dit voorbeeld beperkt de toegang tot het API-eindpunt `ArticleList` tot alleen geauthenticeerde gebruikers.

Aangepaste DRF-permissies

U kunt ook aangepaste DRF-permissieklassen maken om complexere autoratielogica te implementeren. Een aangepaste permissieklasse moet overerven van `rest_framework.permissions.BasePermission` en de methoden `has_permission()` en/of `has_object_permission()` overschrijven.

            
from rest_framework import permissions

class IsAuthorOrReadOnly(permissions.BasePermission):
    """
    Aangepaste permissie om alleen auteurs van een object toe te staan het te bewerken.
    """

    def has_object_permission(self, request, view, obj):
        # Leesmachtiging is toegestaan voor elk verzoek,
        # dus we staan altijd GET-, HEAD- of OPTIONS-verzoeken toe.
        if request.method in permissions.SAFE_METHODS:
            return True

        # Instantie moet een kenmerk met de naam 'auteur' hebben.
        return obj.author == request.user

            

              
                Copy
              
            
          

Dit voorbeeld definieert een aangepaste permissieklasse die alleen de auteur van een artikel toestaat het te bewerken, terwijl leestoegang aan iedereen wordt toegestaan.

Beveiligingsbest practices

Het implementeren van een robuust permissiesysteem is cruciaal voor het beveiligen van uw Django-applicatie. Hier zijn enkele beveiligingsbest practices om in gedachten te houden:

• Principle of Least Privilege: Verleen gebruikers alleen de minimale permissies die ze nodig hebben om hun taken uit te voeren. Vermijd het toewijzen van onnodige permissies.
• Gebruik groepen: Beheer permissies via groepen in plaats van permissies rechtstreeks aan individuele gebruikers toe te wijzen. Dit vereenvoudigt het beheer en vermindert het risico op fouten.
• Regelmatige audits: Bekijk periodiek uw permissie-instellingen om ervoor te zorgen dat ze nog steeds passend zijn en dat er geen ongeautoriseerde toegang wordt verleend.
• Input ontsmetten: Ontsmet altijd de input van gebruikers om injection attacks te voorkomen die uw permissiesysteem kunnen omzeilen.
• Grondig testen: Test uw permissiesysteem grondig om ervoor te zorgen dat het zich gedraagt zoals verwacht en dat er geen kwetsbaarheden bestaan. Schrijf geautomatiseerde tests om permissiecontroles te verifiëren.
• Blijf up-to-date: Houd uw Django-framework en gerelateerde bibliotheken up-to-date om te profiteren van de nieuwste beveiligingspatches en bugfixes.
• Overweeg een Content Security Policy (CSP): Een CSP kan cross-site scripting (XSS)-aanvallen helpen voorkomen, die kunnen worden gebruikt om autorisatiemechanismen te omzeilen.

Internationalisatie overwegingen

Houd bij het ontwerpen van uw permissiesysteem voor een wereldwijd publiek rekening met de volgende internationalisatieaspecten:

• Rolnamen: Als uw applicatie rollen gebruikt (bijv. Redacteur, Auteur, Moderator), zorg er dan voor dat deze rolnamen gemakkelijk vertaalbaar en cultureel passend zijn voor alle ondersteunde talen. Overweeg om taalspecifieke variaties van rolnamen te gebruiken.
• Gebruikersinterface: Ontwerp uw gebruikersinterface zo dat deze zich kan aanpassen aan verschillende talen en culturele conventies. Dit omvat datum/tijd-indelingen, getalnotaties en tekstrichting.
• Tijdzones: Houd rekening met verschillende tijdzones bij het verlenen of intrekken van permissies op basis van tijdgevoelige gebeurtenissen. Sla tijdstempels op in UTC en converteer ze naar de lokale tijdzone van de gebruiker voor weergave.
• Wetgeving inzake gegevensprivacy: Wees op de hoogte van wetgeving inzake gegevensprivacy in verschillende landen (bijvoorbeeld AVG in Europa, CCPA in Californië). Implementeer de juiste toestemmingsmechanismen en maatregelen voor gegevensbescherming.
• Toegankelijkheid: Zorg ervoor dat uw permissiesysteem toegankelijk is voor gebruikers met een handicap, in overeenstemming met toegankelijkheidsstandaarden zoals WCAG.

Conclusie

Django's permissiesysteem biedt een krachtig en flexibel framework voor het beheren van autorisatie in uw webapplicaties. Door de ingebouwde functies, aangepaste permissies, permissies op objectniveau en beveiligingsbest practices te begrijpen, kunt u veilige en schaalbare applicaties bouwen die uw waardevolle resources beschermen. Vergeet niet om uw permissiesysteem aan te passen aan de specifieke behoeften van uw applicatie en om uw instellingen regelmatig te bekijken en bij te werken om ervoor te zorgen dat ze effectief blijven.

Deze gids biedt een uitgebreid overzicht van Django's permissiesysteem. Naarmate u complexere applicaties bouwt, kunt u meer geavanceerde scenario's tegenkomen. Aarzel niet om de Django-documentatie en community-bronnen te verkennen voor verdere begeleiding.