

Doing extravehicular activity on Dev Space | Mainly focused on Python๐ and ML๐ค but love React also
You already know web security is important to keeping hackers and cyber-thieves from accessing sensitive information. So, in this post we are going to check Django security vulnerabilities and how to fix them.
First thing first, check your security vulnerabilities by following command:
manage.py check --deploy
You can see some descriptions which provide information about your Django web application vulnerabilities. Try to google these security issues and fix them before production.
If you already deployed you application then useย Observatory by Mozillaย site to scan the security status of your site. The site also includes third-party scanners which test other security aspects of your site.
Here is the example of scan:
In a web application, basically the webforms take input from the user and send them to server-side components to process them. The server-side components generally expose the service as a
POST
, PUT
, DELETE
methods for accepting the data over HTTP. Django has built-in security against most forms of CSRF threats, as long as you have allowed and used it if necessary.As stated in theย documentation, be very careful when marking views with theย csrf_exemptย decorator, unless it is absolutely necessary.
If someone has access (through an man-in-the-middle attack or xss) to your csrftoken cookie, then this is a vulnerability.
The CSRF protection cannot protect againstย man-in-the-middleย attacks, so useย HTTPSย with HTTP Strict Transport Security (We will discuss it in post later).
Once youโve set up HTTPS, add these lines in yourย settings.py:
CSRF_COOKIE_SECURE = True #to avoid transmitting the CSRF cookie over HTTP accidentally.
SESSION_COOKIE_SECURE = True #to avoid transmitting the session cookie over HTTP accidentally.
A Cross-site Scripting (XSS) allows an attacker to inject a script into the content of a website or app. When a user visits the infected page the script will execute in the victimโs browser. This allows attackers to steal private information like cookies, account information, etc.
X-XSS-Protection: 1; mode=blockย enables XSS filtering. Rather than sanitizing the page, the browser will prevent rendering of the page if an attack is detected.
To enable it in Django, make sure django.middleware.security.SecurityMiddlewareย is present in middleware's list and add following lines in yourย settings.py:
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
One of the most important thing is to make Django administration secure. Before you deploy your application you must changeย admin/ย path to something only you know. Otherwise, someone can easily type /admin in url and access to adminsitrator login page.
#urls.py
from django.contrib import admin
from django.urls import path
urlpatterns = [
path('admin/', admin.site.urls) # change admin something different
You can create fake admin login page usingย django-admin-honeypotย and it will notify you if someone try attempt unauthorized access.
Add following line to yourย settings.pyย to force Django redirect all non-HTTPS requests to HTTPS.
SECURE_SSL_REDIRECT = True
If your Django application is large, contains a lot of third-party code, and has a lot of inline scripts and styles scattered all over the project, then you should add CSP to your site.
For more information about CSP visitย An Introduction to Content Security Policy
Django does not have a built-in method for creating a CSP header, so you can install Mozillaโsย django-cspย module and use your browser's console to track the security violations in your code.
Once you installed django-csp, add following lines to yourย settings.py.
# Content Security Policy
CSP_DEFAULT_SRC = ("'none'", )
CSP_STYLE_SRC = ("'self'", )
CSP_SCRIPT_SRC = ("'self'", )
CSP_IMG_SRC = ("'self'", )
CSP_FONT_SRC = ("'self'", )
So, basically, your all inline scripts and styles will not be allowed anymore. All scripts and styles must be loaded from a resource. You can add โunsafe-inlineโ to your script and style CSP headers, however, it negates the whole policy.
Its really important to clean your code from all these inline styles and scripts. However, some external resources such as Google Tag Manager or Google Analytics should be allowed in your CSP policy. To achieve that update your code like this:
#Content Security Policy
CSP_DEFAULT_SRC = ("'none'", )
CSP_STYLE_SRC = ("'self'", "fonts.googleapis.com", "'sha256-/3kWSXHts8LrwfemLzY9W0tOv5I4eLIhrf0pT8cU0WI='")
CSP_SCRIPT_SRC = ("'self'", "ajax.googleapis.com", "www.googletagmanager.com", "www.google-analytics.com")
CSP_IMG_SRC = ("'self'", "data:", "www.googletagmanager.com", "www.google-analytics.com")
CSP_FONT_SRC = ("'self'", "fonts.gstatic.com")
CSP_CONNECT_SRC = ("'self'", )
CSP_OBJECT_SRC = ("'none'", )
CSP_BASE_URI = ("'none'", )
CSP_FRAME_ANCESTORS = ("'none'", )
CSP_FORM_ACTION = ("'self'", )
CSP_INCLUDE_NONCE_IN = ('script-src',)
Fore more information take a lookย django-csp documentation.
Note that this configuration depends on which external resources you are using so please firstย read the documentationย and then apply changes to your site.
When this policy is set, browsers will refuse to connect to your site for the given time period if youโre not properly serving HTTPS resources, or if your certificate expires.
Add the following lines to yourย settings.py:
SECURE_HSTS_SECONDS = 86400 # 1 day
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
I recommend to useย wemake-django-template. It is a new project boilerplate focused on security and code quality. It has everything from the list. And even several more advanced features!
Now your app is almost secure. Additionally you can scan your open ports by usingย nmapย and try to google how to fix these open ports.
If you liked the post please visitย Reverse Pythonย for more cool stuff like this and share it with your friends!
Stay Connected!
Create your free account to unlock your custom reading experience.