Django
Veiligheid

Cross Site Scripting (XSS) bescherming

XSS-aanvallen bestaan uit het injecteren van HTML-code (of JS) in een pagina. Zie Wat is cross-site scripting voor meer informatie.

Om deze aanval te voorkomen, ontsnapt Django standaard aan strings die door een sjabloonvariabele zijn gegaan.

Gezien de volgende context:

context = {
    'class_name': 'large" style="font-size:4000px',
    'paragraph': (
        "<script type=\"text/javascript\">alert('hello world!');</script>"),
}

<p class="{{ class_name }}">{{ paragraph }}</p>
<!-- Will be rendered as: -->
<p class="large&quot; style=&quot;font-size: 4000px">&lt;script&gt;alert(&#39;hello world!&#39;);&lt;/script&gt;</p>

Als u variabelen met HTML hebt die u vertrouwt en daadwerkelijk wilt weergeven, moet u expliciet zeggen dat het veilig is:

<p class="{{ class_name|safe }}">{{ paragraph }}</p>
<!-- Will be rendered as: -->
<p class="large" style="font-size: 4000px">&lt;script&gt;alert(&#39;hello world!&#39;);&lt;/script&gt;</p>

Als je een blok hebt met meerdere variabelen die allemaal veilig zijn, kun je lokaal escapen lokaal uitschakelen:

{% autoescape off %}
<p class="{{ class_name }}">{{ paragraph }}</p>
{% endautoescape %}
<!-- Will be rendered as: -->
<p class="large" style="font-size: 4000px"><script>alert('hello world!');</script></p>

U kunt een string ook als veilig buiten de sjabloon markeren:

from django.utils.safestring import mark_safe

context = {
    'class_name': 'large" style="font-size:4000px',
    'paragraph': mark_safe(
        "<script type=\"text/javascript\">alert('hello world!');</script>"),
}

<p class="{{ class_name }}">{{ paragraph }}</p>
<!-- Will be rendered as: -->
<p class="large&quot; style=&quot;font-size: 4000px"><script>alert('hello world!');</script></p>

Sommige Django-hulpprogramma's zoals format_html retourneren tekenreeksen die al als veilig zijn gemarkeerd:

from django.utils.html import format_html

context = {
    'var': format_html('<b>{}</b> {}', 'hello', '<i>world!</i>'),
}

<p>{{ var }}</p>
<!-- Will be rendered as -->
<p><b>hello</b> &lt;i&gt;world!&lt;/i&gt;</p>

Clickjacking bescherming

Clickjacking is een kwaadaardige techniek waarbij een webgebruiker wordt misleid om op iets anders te klikken dan de gebruiker waar hij op klikt. Kom meer te weten

Voeg XFrameOptionsMiddleware aan uw middleware-klassen om clickjacking-beveiliging in te schakelen. Dit zou er al moeten zijn als je het niet hebt verwijderd.

# settings.py
MIDDLEWARE_CLASSES = [
    ...
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    ...
]

Deze middleware stelt de kop 'X-Frame-Opties' in op al uw antwoorden, tenzij expliciet vrijgesteld of al ingesteld (niet overschreven indien al ingesteld in het antwoord). Standaard is deze ingesteld op "SAMEORIGIN". Gebruik de instelling X_FRAME_OPTIONS om dit te wijzigen:

X_FRAME_OPTIONS = 'DENY'

U kunt het standaardgedrag per weergave negeren.

from django.utils.decorators import method_decorator
from django.views.decorators.clickjacking import (
    xframe_options_exempt, xframe_options_deny, xframe_options_sameorigin,
)

xframe_options_exempt_m = method_decorator(xframe_options_exempt, name='dispatch')

@xframe_options_sameorigin
def my_view(request, *args, **kwargs):
    """Forces 'X-Frame-Options: SAMEORIGIN'."""
    return HttpResponse(...)

@method_decorator(xframe_options_deny, name='dispatch')
class MyView(View):
    """Forces 'X-Frame-Options: DENY'."""

@xframe_options_exempt_m
class MyView(View):
    """Does not set 'X-Frame-Options' header when passing through the
    XFrameOptionsMiddleware.
    """

Cross-site Request Forgery (CSRF) bescherming

Cross-site verzoekvervalsing, ook bekend als een-klik aanval of sessie rijden en afgekort als CSRF of XSRF, is een soort kwaadaardig misbruik van een website waarbij ongeautoriseerde commando's worden verzonden van een gebruiker die de website vertrouwt. Kom meer te weten

Om CSRF-beveiliging in te schakelen, voegt u CsrfViewMiddleware aan uw middleware-klassen. Deze middleware is standaard ingeschakeld.

# settings.py
MIDDLEWARE_CLASSES = [
    ...
    'django.middleware.csrf.CsrfViewMiddleware',
    ...
]

Deze middleware stelt een token in een cookie in op de uitgaande reactie. Wanneer een inkomende aanvraag een onveilige methode gebruikt (elke methode behalve GET , HEAD , OPTIONS en TRACE ), moet de cookie overeenkomen met een token dat wordt verzonden als de csrfmiddlewaretoken formuliergegevens of als de X-CsrfToken header. Dit zorgt ervoor dat de client die het verzoek indient, ook de eigenaar is van de cookie en, bij uitbreiding, de (geverifieerde) sessie.

Als een verzoek wordt gedaan via HTTPS , is strikte verwijzende controle ingeschakeld. Als de HTTP_REFERER kop niet overeenkomt met de host van het huidige verzoek of een host in CSRF_TRUSTED_ORIGINS ( nieuw in 1.9 ), wordt het verzoek geweigerd.

Formulieren die de POST methode gebruiken, moeten het CSRF-token in de sjabloon opnemen. De sjabloontag {% csrf_token %} geeft een verborgen veld weer en zorgt ervoor dat de cookie wordt ingesteld op de reactie:

<form method='POST'>
{% csrf_token %}
...
</form>

Individuele weergaven die niet kwetsbaar zijn voor CSRF-aanvallen kunnen worden vrijgesteld met behulp van de decorateur @csrf_exempt :

from django.views.decorators.csrf import csrf_exempt

@csrf_exempt
def my_view(request, *args, **kwargs):
    """Allows unsafe methods without CSRF protection"""
    return HttpResponse(...)

Hoewel niet aanbevolen, kunt u de CsrfViewMiddleware uitschakelen als veel van uw weergaven niet kwetsbaar zijn voor CSRF-aanvallen. In dit geval kunt u de decorateur @csrf_protect gebruiken om individuele weergaven te beschermen:

from django.views.decorators.csrf import csrf_protect

@csrf_protect
def my_view(request, *args, **kwargs):
    """This view is protected against CSRF attacks if the middleware is disabled"""
    return HttpResponse(...)