Django har utmärkta säkerhetsfunktioner men det är viktigt att du förstår dem och vad de gör för att dina appar ska vara riktigt säkra.
Django ger en säker grund för att bygga webbapplikationer. Men att förlita sig på Djangos standardsäkerhetsfunktioner är inte tillräckligt. Det är avgörande för dig att implementera ytterligare åtgärder för att stärka säkerheten för dina applikationer.
Genom att implementera ytterligare åtgärder kan du mildra potentiella sårbarheter, skydda känslig data och skydda din applikation från cyberhot. Detta säkerställer skyddet av dina användares information och hjälper till att upprätthålla din organisations rykte och pålitlighet.
Säkra vyer med dekoratörer
Vyer i Django hanterar inkommande förfrågningar. De spelar en avgörande roll för att bestämma vilken respons kunden får. Säkra vyer styr åtkomst och skyddar känsliga funktioner. Django erbjuder dekoratörer som du kan tillämpa på vyer för att upprätthålla specifika säkerhetsåtgärder.
@login_required Dekoratör
De
@Inloggning Krävs decorator ser till att endast autentiserade användare kan komma åt en viss vy. När en oautentiserad användare försöker komma åt vyn, omdirigerar applikationen dem till inloggningssidan.från django.contrib.auth.decorators importera Inloggning Krävs
från django.http importera HttpResponse
@Inloggning Krävs
defsäker_vy(begäran):
# Din synlogik här
lämna tillbaka HttpResponse("Detta är en säker vy")
Att tillämpa @Inloggning Krävs decorator till secure_view-funktionen säkerställer automatiskt att användaren är autentiserad innan vyns logik körs.
Skräddarsydda dekoratörer
Django låter dig skapa skräddarsydda dekoratörer. Detta gör att du kan implementera ytterligare säkerhetskontroller eller begränsningar. Du kanske till exempel vill skapa en dekoratör som begränsar åtkomsten till specifika användarroller.
från funktionsverktyg importera wraps
från django.http importera HttpResponsedefendast admin(view_func):
@wraps (view_func)
defomslag(förfrågan, *args, **kwargs):
om request.user.is_superuser:
lämna tillbaka view_func (request, *args, **kwargs)
annan:
lämna tillbaka HttpResponse("Tillträde beviljas ej")
lämna tillbaka omslag
De endast admin decorator kontrollerar om användaren som kommer åt vyn är en superanvändare. Om de är det, körs visningsfunktionen, annars nekar den användaren åtkomst.
Användarautentisering och auktorisering
Användarautentisering och auktorisering är viktiga komponenter för att säkra Django-applikationer. De säkerställer att rätt person har åtkomst till specifika funktioner i applikationen.
Användarautentisering
Användarautentisering verifierar identiteten på personen som kommer åt din applikation. Djangos autentiseringssystem ger funktionalitet för att hantera detta.
från django.contrib.auth importera autentisera, logga in
från django.http importera HttpResponsedeflogin_view(begäran):
om request.method == 'POSTA':
användarnamn = begäran. POSTA['Användarnamn']
lösenord = begäran. POSTA['Lösenord']
användare = autentisera (begäran, användarnamn=användarnamn, lösenord=lösenord)
om användare ärinteIngen:
inloggning (begäran, användare)
lämna tillbaka HttpResponse("Inloggningen lyckades")
annan:
lämna tillbaka HttpResponse("Ogiltiga uppgifter")
annan:
# Gör inloggningsformulär
lämna tillbaka HttpResponse("Inloggningsformulär")
De login_view funktion hanterar inloggningsprocessen. När en användare skickar in sina autentiseringsuppgifter verifierar autentiseringsfunktionen dem. Om inloggningsuppgifterna är giltiga skapar inloggningsfunktionen en session för användaren, vilket ger dem tillgång till begränsade områden i applikationen. Om referenserna är felaktiga skapar koden ingen session.
Användarbehörighet
Användarbehörighet avgör vilka åtgärder en användare kan utföra i applikationen. Django tillhandahåller ett flexibelt behörighetssystem som ger dig kontroll över användaråtkomst.
från django.contrib.auth.decorators importera permission_required
från django.http importera HttpResponse
@permission_required('polls.can_vote')
defrösta(begäran):
# Röstningslogik här
lämna tillbaka HttpResponse("Röstningen inspelad")
I exemplet ovan är @permission_required dekoratör ser till att endast användare med polls.can_vote behörighet kan komma åt röstvyn. Om en användare utan nödvändig behörighet försöker komma åt vyn nekas de åtkomst.
Implementering av anpassad mellanvara
Middleware sitter mellan webbservern och vyn. Implementering av anpassad mellanprogram lägger till ytterligare säkerhetskontroller eller modifierar förfrågningar och svar. Detta kan bero på skäl som att upprätthålla HTTPS.
från django.http importera HttpResponsePermanentRedirectklassEnforceHttpsMiddleware:
def__i det__(self, get_response):
self.get_response = get_responsedef__ring upp__(själv, begäran):
ominte request.is_secure():
url = request.build_absolute_uri (request.get_full_path())
secure_url = url.replace(' http://', ' https://')
lämna tillbaka HttpResponsePermanentRedirect (secure_url)
lämna tillbaka self.get_response (request)
Ovanstående mellanprogram kontrollerar om begäran använder är_säkert metod. Om inte, omdirigerar den till HTTPS-version av webbadressen.
Säkra filhantering
Filhantering är en vanlig funktion i webbapplikationer. Det utgör säkerhetsrisker om det inte är ordentligt säkrat. När du hanterar användaruppladdade filer är det viktigt att validera filinnehållet. Detta förhindrar skadliga uppladdningar. Du kan validera filtyperna med Djangos FileExtensionValidator.
från django.core.validators importera FileExtensionValidator
från django.forms importera formulär
klassFileUploadForm(formulär. Form):
fil = formulär. FileField (validators=[FileExtensionValidator (allowed_extensions=['pdf', 'docx'])])
I kodblocket ovan visas FileUploadForm klass använder FileExtensionValidator för att endast tillåta PDF- och DOCX-filuppladdningar. Applikationen kommer att avvisa alla andra filformat under uppladdningen. Anpassa de tillåtna tilläggen enligt din applikations krav.
CSRF-skydd
Du kan förhindra Cross-Site Request Forgery (CSRF)-attacker med Djangos inbyggda CSRF-skydd. Du bör inkludera ett i din mall CSRF-token som kommer att valideras på serversidan.
När du använder % csrf_token % malltagg, genererar Django ett dolt inmatningsfält med CSRF-token. Denna token är unik för varje användarsession. Det hjälper till att validera det inskickade formulärets äkthet.
Serversidan kontrollerar CSRF-token vid bearbetning av formulärinlämningen. Om token saknas eller är ogiltig, ställer Django upp ett Forbidden (HTTP 403) fel. Det är viktigt att se till att din applikation är säker från denna typ av säkerhetsrisk.
Skriva säkra formulär
När du skapar formulär är det viktigt att hantera användarinmatning på ett säkert sätt. Detta för att förhindra vanliga sårbarheter som SQL-injektion och XSS-attacker. Nedan är ett exempel som visar hur du kan skapa ett säkert formulär i Django.
från django importera formulär
från django.utils.html importera flyklassSecureForm(formulär. Form):
namn = former. CharField (max_length=100)
e-post = formulär. EmailField()defrent_namn(själv):
namn = self.cleaned_data['namn']# Rensa användarinmatning
sanitized_name = escape (namn)
lämna tillbaka sanitized_namedefren_e-post(själv):
email = self.cleaned_data['e-post']# Validera och rensa användarinmatningar
ominte email.endswith('@exempel.com'):
höja formulär. Valideringsfel("Ogiltig e-postdomän")
sanitized_email = escape (e-post)
lämna tillbaka sanitized_email
De rent_namn och ren_e-post metoder validerar och sanerar användarinmatningen. De rent_namn metoden använder fly funktion för att rensa namninmatningen och förhindra potentiella XSS-attacker.
De ren_e-post metoden validerar e-postformatet och begränsar e-postdomänen till exempel.com. Det väcker en Valideringsfel om e-postmeddelandet inte uppfyller de angivna kriterierna. Denna åtgärd förbättrar säkerheten för dina formulär och skyddar dem mot vanliga sårbarheter.
Det är viktigt att förstå webbapplikationers sårbarheter
Att förstå webbapplikationssårbarheter hjälper dig att säkra din applikation. Det kommer att göra det genom att hjälpa dig att identifiera och åtgärda potentiella svaga punkter i applikationen. Detta kommer i sin tur att avsevärt minska sannolikheten för framgångsrika attacker.