Безопасность — ключевой аспект разработки веб-приложений. Но это понятие очень широкое, поэтому для его понимания нужно четко определить роль безопасности в современных веб-приложениях и то, какие аспекты она охватывает.
Я Алексей Петров, программист в команде коммуникационной платформы VK WorkSpace, расскажу о конкретных угрозах, с которыми сталкиваются веб-приложения, и о том, как грамотно защищать приложения, написанные на фреймворке Django.
Самые популярные угрозы для веб-приложений
Без лишних предисловий — сразу к угрозам. Если вы и так о них все знаете, можете переходить к следующему разделу.
1. Инъекции
Инъекции — это атаки, при которых злоумышленники внедряют во входные данные вредоносный код, который затем выполняется на стороне сервера. Наиболее распространенными являются:
SQL-инъекции, когда злоумышленник внедряет SQL-код в формы ввода;
инъекции кода, когда вредоносный код передается для выполнения на сервере.
2. Межсайтовая подделка запросов (CSRF)
Атаки CSRF основаны на том, что злоумышленник обманывает пользователя и заставляет его выполнить нежелательное действие без его согласия. Защита от CSRF включает в себя использование токенов, связанных с сессией пользователя, для подтверждения подлинности запросов.
Если не использовать защиту CSRF (Cross-Site Request Forgery) в Django, ваше веб-приложение становится уязвимым для атак, связанных с межсайтовой подделкой запросов. Вот некоторые примеры того, что может произойти:
Атака на сеанс пользователя. Злоумышленники могут создавать поддельные запросы с целью выполнить действия от имени аутентифицированных пользователей без их ведома. Например, атакующий может отправить запрос на изменение электронной почты или пароля пользователя, если необходимые параметры запроса доступны.
Внедрение вредоносного контента. Злоумышленники могут создавать поддельные формы, которые автоматически отправляют POST-запросы на ваше приложение от имени аутентифицированных пользователей. Это может привести к внедрению контента или выполнению действий, таких как изменение данных пользователя или размещение вредоносных скриптов.
Фишинговые атаки. Злоумышленники могут использовать отсутствие защиты CSRF для проведения фишинговых атак. Это обманывает пользователей и может заставить их выполнить нежелательные действия: отправить конфиденциальную информацию или провести финансовую операцию.
Создание нежелательного контента. Злоумышленники могут создавать множество поддельных запросов, чтобы заполнить вашу базу данных нежелательным или вредоносным контентом. Это может привести к ухудшению производительности приложения и повреждению данных.
3. Кросс-сайтовый скриптинг (XSS)
XSS — это атака, при которой злоумышленник внедряет вредоносный скрипт в веб-страницу. Этот скрипт выполняется на стороне клиента и может привести к украденным сессиям, перехвату данных и другим проблемам. Защита включает в себя правильную фильтрацию и экранирование выводимых данных.
Вот несколько примеров того, что может произойти, если не использовать защиту от XSS в Django:
Внедрение вредоносных скриптов. Злоумышленники могут внедрять вредоносные скрипты в ваше приложение, которые будут выполняться на стороне клиента при загрузке веб-страницы. Это может привести к краже сессионных файлов, перенаправлению пользователя на вредоносные сайты, фишинговым атакам и другим вредоносным действиям.
Кража куки и данных сессии. Злоумышленники могут использовать XSS для кражи сессионных файлов и куков, хранящихся в браузере пользователя. Это позволяет им выполнять действия от имени аутентифицированных пользователей, такие как изменение данных профиля или выполнение финансовых операций.
4. Отказ в обслуживании (DoS) и распределенный отказ в обслуживании (DDoS)
Атаки DoS и DDoS направлены на перегрузку сервера или сети и делают приложение недоступным для легитимных пользователей. Это можно сделать с помощью большого количества запросов или применения ботнетов для высокой нагрузки.
Часть 1: Основы безопасности в Django
Пора от теории переходить к практике — на конкретных примерах разбирать защиту от разных типов угроз. Тут кода будет больше, чем текста — сразу приготовьтесь.
1. Защита от атак на основе инъекций
Параметризованные запросы в Django — это способ выполнения SQL-запросов к базе данных с использованием параметров, которые передаются отдельно от запроса. Это позволяет избежать SQL-инъекций и повысить безопасность вашего приложения. Вот как можно использовать параметризованные запросы в Django:
Использование ORM. Одним из наиболее безопасных способов выполнения параметризованных запросов в Django является использование ORM. Django ORM автоматически экранирует пользовательский ввод и предотвращает SQL-инъекции.
```python
from myapp.models import MyModel
# Получение объектов модели с фильтром по полю
results = MyModel.objects.filter(name='example')
```Raw SQL с параметрами. Если вам нужно использовать сырые SQL-запросы, Django предоставляет методы для выполнения параметризованных запросов через RawSQL или execute.
```python
from django.db import connection
# Выполнение сырого SQL-запроса с параметрами
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM myapp_mymodel WHERE name = %s", ['example'])
results = cursor.fetchall()
```В этом примере %s используется для маркировки места параметров в запросе, а список ['example'] представляет собой значения этих параметров.
Но помните, что ORM предпочтительнее, так как обеспечивает более высокий уровень безопасности и удобства.
2. Защита от межсайтовой подделки запросов (CSRF)
Использование {% csrf_token %} в шаблонах. CSRF-атаки могут быть предотвращены с использованием механизма токенов в Django. Включение токена в формы веб-страниц позволяет приложению проверять подлинность запросов. Разработчики должны активно использовать {% csrf_token %} в шаблонах, где требуется форма ввода данных.
Проверка заголовков запросов на наличие токена. Дополнительной стратегией защиты от CSRF-атак является проверка заголовков запросов на наличие корректного токена. Это добавляет дополнительный уровень безопасности, предотвращая атаки, даже если токен был somehow украден.
Рассмотрим пример реализации защиты от XSRF/CSRF в Django.
Включение защиты от CSRF в Django
Django автоматически включает защиту от CSRF, но важно убедиться, что все необходимые настройки присутствуют в вашем проекте.
Убедитесь, что CSRF Middleware включен
Проверьте, что `CsrfViewMiddleware` включен в настройках `MIDDLEWARE` вашего файла `settings.py`:
```python
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware', # Защита от CSRF
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
```Убедитесь, что CSRF-токен добавляется в шаблоны
Django использует шаблонный тег `{% csrf_token %}`, чтобы включить CSRF-токен в формы. Убедитесь, что все формы в ваших шаблонах содержат этот тег.
Пример формы с защитой от CSRF
Создадим простую форму, которая будет защищена от CSRF-атак.
Создание формы
Создайте форму в `forms.py`:
```python
from django import forms
class CommentForm(forms.Form):
comment = forms.CharField(widget=forms.Textarea, label='Leave a comment')
```Создание представления
Создайте представление в `views.py`:
```python
from django.shortcuts import render, redirect
from django.views.decorators.csrf import csrf_protect
from .forms import CommentForm
@csrf_protect
def leave_comment(request):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
# Обработка комментария
return redirect('thank_you')
else:
form = CommentForm()
return render(request, 'leave_comment.html', {'form': form})
```Создание шаблона
Создайте шаблон `leave_comment.html`:
```html
<!DOCTYPE html>
<html>
<head>
<title>Leave a Comment</title>
</head>
<body>
<h1>Leave a Comment</h1>
<form method="post">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Submit</button>
</form>
</body>
</html>
```Тестирование защиты от CSRF
Попробуйте отправить форму без CSRF-токена: Удалите строку `{% csrf_token %}` из формы и попробуйте отправить данные. Django должен вернуть ошибку CSRF-валидации.
Проверьте правильную работу с CSRF-токеном: Верните `{% csrf_token %}` в форму и убедитесь, что данные отправляются корректно.
Дополнительные меры защиты
Настройка CSRF_TRUSTED_ORIGINS
В `settings.py` можно добавить доверенные источники для CSRF-защиты:
```python
CSRF_TRUSTED_ORIGINS = [
'https://yourdomain.com',
'https://www.yourdomain.com',
]
```Защита AJAX-запросов
Для защиты AJAX-запросов необходимо включить CSRF-токен в заголовки. Пример использования jQuery:
```javascript
function getCookie(name) {
let cookieValue = null;
if (document.cookie && document.cookie !== '') {
const cookies = document.cookie.split(';');
for (let i = 0; i < cookies.length; i++) {
const cookie = cookies[i].trim();
if (cookie.substring(0, name.length + 1) === (name + '=')) {
cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
break;
}
}
}
return cookieValue;
}
const csrftoken = getCookie('csrftoken');
$.ajaxSetup({
beforeSend: function(xhr, settings) {
if (!this.crossDomain) {
xhr.setRequestHeader("X-CSRFToken", csrftoken);
}
}
});
```3. Ограничение доступа и защита от переполнения буфера (CSRF)
Корректная настройка прав доступа к ресурсам приложения предотвращает несанкционированный доступ и минимизирует риски утечки данных. Разработчики должны строго следовать принципам настройки прав доступа к различным уровням приложения.
Для предотвращения атак на переполнение буфера, включая DoS, важно ограничивать размер загружаемых файлов. Это помогает предотвратить атаки, связанные с отправкой больших объемов данных, которые могут нарушить функционирование сервера.
В Django есть несколько способов ограничить размер загружаемых файлов. Вот некоторые из них:
Настройка параметра DATA_UPLOAD_MAX_MEMORY_SIZE. Django имеет параметр DATA_UPLOAD_MAX_MEMORY_SIZE, который определяет максимальный размер данных, которые могут быть сохранены в памяти перед записью на диск. По умолчанию этот параметр равен 2,5 МБ. Однако вы можете изменить его в настройках вашего проекта. Например:
```python
# settings.py
DATA_UPLOAD_MAX_MEMORY_SIZE = 10 * 1024 * 1024 # 10 MB
``` Использование параметра FILE_UPLOAD_MAX_MEMORY_SIZE. Этот параметр определяет максимальный размер файла, который может быть загружен в память. Если файл превышает этот размер, он будет сохранен на диск. По умолчанию он равен 2,5 МБ, но вы можете изменить его в настройках проекта. Например:
```python
# settings.py
FILE_UPLOAD_MAX_MEMORY_SIZE = 10 * 1024 * 1024 # 10 MB
```*Использование параметра MAX_UPLOAD_SIZE. В Django 3.1 и выше вы можете использовать параметр MAX_UPLOAD_SIZE в конфигурации формы для ограничения размера загружаемых файлов. Например:
```python
# forms.py
from django import forms
class MyForm(forms.Form):
file_field = forms.FileField(max_length=10)
```В этом примере max_length определяет максимальный размер загружаемого файла в байтах.
Использование CONTENT_TYPES и CONTENT_TYPES_EXTRA в FileField или ImageField. Эти параметры позволяют ограничить типы файлов, которые могут быть загружены, что также может помочь предотвратить атаки загрузкой вредоносных файлов. Например:
```python
# models.py
from django.db import models
class MyModel(models.Model):
file_field = models.FileField(upload_to='uploads/', content_types=['image/jpeg', 'image/png'])
```В этом примере указаны допустимые типы файлов (JPEG и PNG).
Выберите подход, который лучше всего соответствует вашим потребностям и требованиям безопасности, и настройте его в своем проекте Django.
4. Использование HTTPS для защиты передаваемых данных
Получение и установка SSL-сертификата
Защита данных в пути между клиентом и сервером — это основной аспект безопасности. Получение и установка SSL-сертификата обеспечивают шифрование передаваемых данных, делая их недоступными для потенциальных злоумышленников.
В Django SSL-сертификаты обычно устанавливаются на уровне веб-сервера, такого как Apache или Nginx, который работает в качестве прокси для вашего Django-приложения. Однако Django также имеет некоторую поддержку HTTPS и SSL, которая может быть использована в различных случаях. Вот некоторые рекомендации по получению и установке SSL-сертификата в Django:
Получение SSL-сертификата. Сначала вам нужно получить SSL-сертификат для вашего домена. Вы можете приобрести его у сертифицированных удостоверяющих центров (CA) или воспользоваться бесплатными сервисами, такими как Let's Encrypt.
Установка SSL-сертификата на веб-сервере. После получения SSL-сертификата установите его на вашем веб-сервере. Этот процесс зависит от используемого вами веб-сервера (например, Apache, Nginx). Вам потребуется указать путь к закрытому ключу (private key) и путь к SSL-сертификату в конфигурации вашего веб-сервера.
Конфигурация Django для работы с HTTPS. После установки SSL-сертификата на веб-сервере укажите Django использовать HTTPS. В вашем файле settings.py добавьте следующую настройку:
```python
SECURE_SSL_REDIRECT = True
```Эта настройка перенаправит все запросы на HTTPS, гарантируя, что ваше приложение будет работать только через защищенное соединение.
Проверка работоспособности HTTPS. После настройки SSL-сертификата и HTTPS убедитесь, что ваше приложение правильно работает через защищенное соединение. Перейдите на ваш сайт с использованием HTTPS и убедитесь, что он загружается без ошибок.
Обновление ссылок на ресурсы. Убедитесь, что все ссылки на ресурсы в вашем приложении (например, изображения, стили, скрипты) используют префикс HTTPS, чтобы избежать ошибок загрузки на защищенном соединении.
После выполнения этих шагов ваше Django-приложение будет работать через защищенное HTTPS-соединение с помощью установленного SSL-сертификата.
Настройка проекта для работы с HTTPS
Этот шаг обеспечивает конфиденциальность данных и предотвращает атаки, направленные на перехват их в пути.
Эффективная защита веб-приложения требует системного подхода и внедрения множества стратегий. Защита от инъекций, CSRF, ограничение доступа и использование HTTPS — все эти меры совместно образуют надежный щит, защищающий приложение от множества угроз и обеспечивающий высокий уровень безопасности данных.
Чтобы обновить настройки Django для работы с HTTPS, в файле settings.py вашего проекта Django включите поддержку HTTPS и настройте некоторые параметры безопасности:
```python
# Указывает Django использовать HTTPS при генерации ссылок и перенаправлении
SECURE_SSL_REDIRECT = True
# Указывает Django использовать заголовок HTTP Strict Transport Security (HSTS)
SECURE_HSTS_SECONDS = 31536000 # Год
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
# Указывает браузерам отправлять куки только через защищенное HTTPS-соединение
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
# Указывает Django использовать безопасные куки
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
```Эти настройки помогут защитить ваше приложение от некоторых типов атак, связанных с HTTPS.
Часть 2: Аутентификация и авторизация: Стратегии обеспечения безопасности пользователя в Django
Аутентификация и авторизация — это краеугольные камни безопасности веб-приложений, и в Django эти механизмы разработаны с учетом высоких стандартов безопасности. В этой главе мы рассмотрим эффективные стратегии аутентификации пользователей и управления их правами доступа.
Реализация безопасной системы аутентификации
Использование Django's built-in-User-модели
Django предоставляет встроенную модель пользователя (User), которая включает в себя базовые механизмы аутентификации. Использование этой модели упрощает процесс создания безопасной системы входа в систему, обеспечивая уникальность и шифрование паролей.
Использование встроенной модели пользователя (User) в Django предоставляет удобный способ управления аутентификацией и авторизацией в вашем веб-приложении. Вот как можно использовать встроенную модель пользователя:
Импортирование модели пользователя. В вашем приложении Django импортируйте встроенную модель пользователя следующим образом:
```python
from django.contrib.auth.models import User
```Создание нового пользователя. Вы можете создать нового пользователя с помощью конструктора модели User:
```python
user = User.objects.create_user(username='username', email='email@example.com', password='password')
```Это создаст нового пользователя с заданным именем пользователя, адресом электронной почты и паролем.
Аутентификация пользователей. Для аутентификации пользователей вы можете использовать функцию authenticate():
```python
from django.contrib.auth import authenticate
user = authenticate(username='username', password='password')
if user is not None:
# Пользователь успешно аутентифицирован
else:
# Неверные учетные данные
```Авторизация пользователей. После аутентификации пользователь будет доступен в атрибуте request.user в представлениях Django. Вы можете проверить, имеет ли пользователь определенные права доступа, с помощью декораторов или методов проверки прав доступа:
```python
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseForbidden
@login_required
def my_view(request):
if request.user.has_perm('myapp.can_view_content'):
# Пользователь имеет разрешение на просмотр контента
return HttpResponse('Содержимое страницы')
else:
return HttpResponseForbidden('Доступ запрещен')
```Изменение пароля пользователя. Для изменения пароля пользователя используйте метод set_password():
```python
user.set_password('новый_пароль')
user.save()
```Дополнительные атрибуты пользователя. Кроме стандартных атрибутов, таких как имя пользователя, адрес электронной почты и пароль, вы можете добавлять дополнительные атрибуты пользователей, определяя профиль пользователя или используя расширения модели.
Это основные способы использования встроенной модели пользователя в Django. Она предоставляет удобный интерфейс для реализации аутентификации и авторизации в ваших веб-приложениях.
Двухфакторная аутентификация
Внедрение двухфакторной аутентификации (2FA) повышает уровень безопасности. Помимо стандартного пароля, пользователю требуется предоставить дополнительную форму идентификации, такую как одноразовый код или биометрические данные. Django поддерживает 2FA через сторонние библиотеки и позволяет легко интегрировать этот слой защиты.
Выбор библиотеки для двухфакторной аутентификации. Вот несколько популярных библиотек для реализации двухфакторной аутентификации в Django:
django-two-factor-auth: Это одна из наиболее популярных библиотек для двухфакторной аутентификации в Django. Она предоставляет готовое решение для включения двухфакторной аутентификации с поддержкой различных методов второго фактора, таких как SMS, email, аутентификаторы временного доступа и другие.
django-otp: Эта библиотека предоставляет инструменты для реализации одноразовых паролей (OTP) и двухфакторной аутентификации в Django. Она также предоставляет различные методы второго фактора, такие как аутентификаторы временного доступа, SMS и email.
django-mfa: Это еще одна библиотека для реализации многофакторной аутентификации (MFA) в Django. Она предоставляет гибкую систему для настройки различных методов аутентификации и поддерживает аутентификаторы временного доступа, SMS, email, а также кастомные методы аутентификации.
django-otp-yubikey: Эта библиотека расширяет функциональность django-otp для интеграции с YubiKey, позволяя пользователям использовать YubiKey в качестве второго фактора аутентификации.
django-otp-email: Это расширение для django-otp, которое добавляет возможность использовать email в качестве второго фактора аутентификации. Оно предоставляет интеграцию с почтовыми провайдерами для отправки одноразовых кодов аутентификации на email.
Эти библиотеки предлагают готовые решения для реализации двухфакторной аутентификации в ваших проектах Django. Выбор конкретной библиотеки зависит от ваших требований и предпочтений, поэтому обязательно ознакомьтесь с их документацией и функциональностью перед принятием решения.
Установка и настройка библиотеки. После выбора библиотеки установите ее и выполните необходимые настройки в файле settings.py. Обычно это включает включение и настройку двухфакторной аутентификации, указание методов второго фактора (например, SMS, email, аутентификаторы временного доступа и т. д.).
Добавление полей второго фактора в модель пользователя. Большинство библиотек для двухфакторной аутентификации требуют добавления дополнительных полей в модель пользователя Django для хранения информации о втором факторе. Обычно это делается путем настройки профилей пользователей или расширения встроенной модели пользователя.
Настройка представлений и шаблонов. Обычно вам нужно будет настроить представления и шаблоны для ввода и подтверждения кодов второго фактора. Это может включать в себя создание страниц для ввода кодов, генерации и отправки кодов по SMS или email и т. д.
Тестирование и развертывание. После настройки двухфакторной аутентификации важно протестировать ее, чтобы убедиться, что все работает правильно. Затем разверните ваше приложение, чтобы пользователи могли использовать новый функционал двухфакторной аутентификации.
Поддержка и обслуживание. После развертывания регулярно обслуживайте и поддерживайте вашу систему двухфакторной аутентификации. Это включает в себя мониторинг безопасности, обновление зависимостей и регулярное тестирование.
Установка и настройка библиотеки
Для примера возьмем библиотеку Django Two-Factor Authentication (django-otp, django-two-factor-auth).
1. Установите библиотеку:
```bash
pip install django-two-factor-auth
```2. Настройте `settings.py`:
```python
INSTALLED_APPS = [
# другие приложения
'django_otp',
'django_otp.plugins.otp_totp',
'django_otp.plugins.otp_static',
'two_factor',
]
MIDDLEWARE = [
# другие middleware
'django_otp.middleware.OTPMiddleware',
]
TWO_FACTOR_SMS_GATEWAY = 'two_factor.gateways.fake.Fake'
TWO_FACTOR_CALL_GATEWAY = 'two_factor.gateways.fake.Fake'
```Добавление полей второго фактора в модель пользователя
Если вы хотите добавить дополнительные поля для модели пользователя, вы можете использовать One-to-one-связку с профилем пользователя:
```python
from django.conf import settings
from django.db import models
from django.contrib.auth.models import User
class UserProfile(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
phone_number = models.CharField(max_length=15, blank=True, null=True)
is_phone_verified = models.BooleanField(default=False)
```Не забудьте создать сигналы для автоматического создания и сохранения профилей пользователей:
```python
from django.db.models.signals import post_save
from django.dispatch import receiver
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
if created:
UserProfile.objects.create(user=instance)
@receiver(post_save, sender=User)
def save_user_profile(sender, instance, **kwargs):
instance.userprofile.save()
```Настройка представлений и шаблонов
Создайте представления для ввода и подтверждения кодов второго фактора. Пример для ввода кода:
```python
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from django.utils import timezone
from .models import TwoFactorCode
from .forms import TwoFactorCodeForm
from two_factor.views import LoginView
class CustomLoginView(LoginView):
template_name = 'two_factor/login.html'
@login_required
def enter_code(request):
if request.method == 'POST':
form = TwoFactorCodeForm(request.POST)
if form.is_valid():
code = form.cleaned_data['code']
user_code = TwoFactorCode.objects.filter(user=request.user, code=code).first()
if user_code and user_code.is_valid():
return redirect('home')
else:
form.add_error('code', 'Invalid or expired code.')
else:
form = TwoFactorCodeForm()
return render(request, 'two_factor/enter_code.html', {'form': form})
@login_required
def generate_and_send_code(request):
code = str(uuid.uuid4().int)[:6]
TwoFactorCode.objects.create(user=request.user, code=code)
send_code_via_email_or_sms(request.user, code)
return redirect('enter_code')
def send_code_via_email_or_sms(user, code):
# Логика для отправки кода
pass
```Шаблон `enter_code.html`:
```html
<!DOCTYPE html>
<html>
<head>
<title>Enter Two-Factor Code</title>
</head>
<body>
<h1>Enter Two-Factor Code</h1>
<form method="post">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Submit</button>
</form>
</body>
</html>
```Настройка URL
В `urls.py` приложения добавьте маршруты для новых представлений:
```python
from django.urls import path
from . import views
urlpatterns = [
path('enter-code/', views.enter_code, name='enter_code'),
path('generate-code/', views.generate_and_send_code, name='generate_code'),
]
```Тестирование и развертывание
1. Тестирование: Убедитесь, что вы тщательно протестировали двухфакторную аутентификацию. Создайте тестовых пользователей и выполните весь процесс аутентификации, чтобы убедиться в его работоспособности.
2. Развертывание: Разверните ваше приложение на сервере. Убедитесь, что все необходимые настройки и зависимости установлены. Также настройте отправку SMS и email для рабочей среды.
```bash
# Пример развертывания с использованием Gunicorn и Nginx
pip install gunicorn
gunicorn myproject.wsgi:application --bind 0.0.0.0:8000
```Не забудьте настроить ваш веб-сервер (например, Nginx или Apache) для обработки запросов к вашему приложению.
Защита паролей пользователей
Хэширование паролей
```bash
# Пример развертывания с использованием Gunicorn и Nginx
pip install gunicorn
gunicorn myproject.wsgi:application --bind 0.0.0.0:8000
```Django автоматически хэширует пароли пользователей перед сохранением в базе данных, используя сильные хэш-функции. Это предотвращает утечку чувствительных данных, даже если база данных подвергнется атаке.
В Django хэширование паролей обеспечивается встроенным механизмом аутентификации, который автоматически хэширует пароли пользователей перед сохранением их в базе данных. Вот как настроить хэширование паролей в Django:
Использование встроенной модели пользователя. При использовании встроенной модели пользователя Django (django.contrib.auth.models.User) пароли автоматически хэшируются при их сохранении в базу данных.
Настройка алгоритма хэширования. По умолчанию Django использует алгоритм хэширования PBKDF2 с SHA-256 для хэширования паролей. Однако вы можете изменить этот алгоритм в файле settings.py, установив параметр PASSWORD_HASHERS. Например:
```python
PASSWORD_HASHERS = [
'django.contrib.auth.hashers.BCryptSHA256PasswordHasher',
'django.contrib.auth.hashers.PBKDF2PasswordHasher',
]
```В этом примере используется BCryptSHA256PasswordHasher и PBKDF2PasswordHasher в качестве алгоритмов хэширования паролей.
Использование кастомных алгоритмов хэширования. Вы также можете создавать собственные кастомные алгоритмы хэширования, если вам нужно более специфичное поведение. Для этого вам нужно создать класс, который наследует django.contrib.auth.hashers.BasePasswordHasher, и реализовать методы encode и verify.
```python
from django.contrib.auth.hashers import BasePasswordHasher
class MyCustomPasswordHasher(BasePasswordHasher):
...
```Использование функций хэширования в коде. В некоторых случаях вам может потребоваться хэшировать пароли или другие данные в коде вашего приложения. Для этого вы можете использовать функции хэширования, предоставляемые Django:
```python
from django.contrib.auth.hashers import make_password, check_password
hashed_password = make_password('my_password')
is_password_valid = check_password('my_password', hashed_password)
```Функция make_password хэширует пароль, а heck_password проверяет его на соответствие хэшированной версии.
Ограничение попыток входа и блокировка аккаунтов
Ограничение попыток входа и блокировка аккаунтов после нескольких неудачных попыток — это дополнительный слой защиты. Django предоставляет механизмы для настройки этих параметров, что обеспечивает предотвращение брутфорс-атак и защиту от несанкционированного доступа.
Для ограничения попыток входа и блокировки аккаунтов в Django можно использовать стандартные инструменты аутентификации и дополнительные библиотеки.
Использование встроенных средств Django. Django предоставляет некоторые стандартные инструменты для ограничения попыток входа и блокировки аккаунтов. Например, вы можете использовать django.contrib.auth.models.User и его атрибут failed_attempts для отслеживания неудачных попыток входа и временной блокировки аккаунтов.
Настройка параметров безопасности. В файле settings.py вашего проекта Django можно настроить различные параметры безопасности, связанные с аутентификацией. Например, вы можете использовать следующие параметры для ограничения попыток входа и блокировки аккаунтов:
```python
# Максимальное количество неудачных попыток входа до временной блокировки аккаунта
LOGIN_ATTEMPTS_LIMIT = 3
# Время блокировки аккаунта после достижения лимита неудачных попыток входа (в секундах)
LOGIN_ATTEMPTS_TIMEOUT = 300 # Например, блокировка на 5 минут
```Эти параметры позволяют настроить максимальное количество неудачных попыток входа и время блокировки аккаунта после достижения этого предела.
Использование дополнительных библиотек. В дополнение к стандартным средствам Django вы можете использовать сторонние библиотеки для более продвинутых функций ограничения попыток входа и блокировки аккаунтов. Например, django-axes — это популярная библиотека для Django, которая предоставляет расширенные функции контроля доступа, включая блокировку аккаунтов после нескольких неудачных попыток входа.
Установите библиотеку django-axes с помощью pip:
```
pip install django-axes
``` После установки настройте ее в файле settings.py:
```python
# Настройки django-axes
AXES_FAILURE_LIMIT = 3
AXES_LOCKOUT_TEMPLATE = 'axes/lockout.html'
```Это позволит вам использовать более гибкие и настраиваемые функции для ограничения попыток входа и блокировки аккаунтов.
Использование групп и разрешений
Группы и разрешения в Django позволяют более гибко определять права доступа пользователей. Создание пользовательских групп с определенными разрешениями упрощает управление доступом к функционалу приложения. Это помогает предотвратить несанкционированный доступ к чувствительным ресурсам.
В Django группы и разрешения предоставляют механизм управления доступом к различным частям вашего приложения. Вот как всё настроить:
Создание групп. Сначала создайте необходимые группы пользователей. Группы объединяют пользователей с общими правами доступа. Вы можете создать их через административный интерфейс Django или в коде вашего приложения.
```python
from django.contrib.auth.models import Group
# Создание группы
group = Group(name='Менеджеры')
group.save()
```Назначение разрешений группам. После создания группы назначьте ей необходимые разрешения. Разрешения определяют, какие действия могут выполнять пользователи в этой группе.
```python
from django.contrib.auth.models import Permission
# Получение разрешения
permission = Permission.objects.get(name='Can add article')
# Назначение разрешения группе
group.permissions.add(permission)
```Назначение пользователей группам. После настройки групп и разрешений назначьте пользователей к нужным группам.
```python
from django.contrib.auth.models import User
# Получение пользователя
user = User.objects.get(username='user')
# Назначение пользователя группе
user.groups.add(group)
```Проверка разрешений. Теперь вы можете проверять разрешения в вашем коде, чтобы разрешить или запретить доступ к определенным частям приложения в зависимости от группы пользователя.
```python
from django.contrib.auth.decorators import permission_required
from django.shortcuts import render
@permission_required('app.add_article')
def add_article(request):
# Ваш код для добавления статьи
return render(request, 'add_article.html')
```Использование в шаблонах. Вы также можете использовать проверку разрешений в ваших шаблонах.
```html
{% if perms.app.add_article %}
<a href="{% url 'add_article' %}">Добавить статью</a>
{% endif %}
```Определение декораторов доступа к представлениям
Декораторы доступа в Django — это инструмент для определения прав доступа к представлениям. Их использование позволяет контролировать, какие пользователи имеют доступ к определенным страницам или функционалу. Декораторы обеспечивают удобный способ реализации принципов авторизации и ограничения доступа.
Аутентификация и авторизация — это ключевые элементы обеспечения безопасности пользователя в веб-приложениях. Django предоставляет мощные инструменты для их эффективной реализации. Правильная конфигурация и использование встроенных механизмов помогают создать надежную систему безопасности, предотвращающую угрозы и обеспечивающую защиту данных пользователей.
В Django декораторы доступа к представлениям используются для контроля доступа к определенным представлениям на основе определенных прав или условий. Вот несколько типов декораторов доступа к представлениям в Django:
@login_required. Этот декоратор требует, чтобы пользователь был аутентифицирован, прежде чем он сможет получить доступ к представлению. Если пользователь не аутентифицирован, он будет перенаправлен на страницу входа.
```python
from django.contrib.auth.decorators import login_required
@login_required
def my_view(request):
...
```@permission_required. Этот декоратор требует, чтобы пользователь имел определенное разрешение, прежде чем он сможет получить доступ к представлению. Если у пользователя нет необходимого разрешения, он будет перенаправлен на страницу ошибки доступа.
```python
from django.contrib.auth.decorators import permission_required
@permission_required('app.add_article')
def add_article(request):
...
```@user_passes_test. Этот декоратор позволяет определять собственные функции проверки доступа, которые должны быть выполнены, чтобы пользователь имел доступ к представлению.
```python
from django.contrib.auth.decorators import user_passes_test
def is_manager(user):
return user.groups.filter(name='Менеджеры').exists()
@user_passes_test(is_manager)
def management_view(request):
...
```@permission_required_or_403. Этот декоратор аналогичен @permission_required, но вместо перенаправления на страницу ошибки доступа он возвращает ошибку 403 Forbidden.
```python
from django.contrib.auth.decorators import permission_required_or_403
@permission_required_or_403('app.add_article')
def add_article(request):
...
```@group_required. Этот декоратор проверяет, принадлежит ли пользователь к определенной группе, прежде чем он сможет получить доступ к представлению.
```python
from django.contrib.auth.decorators import user_passes_test
def group_required(group_name):
def decorator(view_func):
def wrapper(request, *args, kwargs):
if request.user.groups.filter(name=group_name).exists():
return view_func(request, *args, kwargs)
else:
return HttpResponseForbidden()
return wrapper
return decorator
@group_required('Менеджеры')
def management_view(request):
...
```Часть 3: Защита от инъекций и зловредных кодов в Django
Фильтрация и экранирование входных данных
Использование Django Forms для валидации
Одним из важных моментов в защите от инъекций — это правильная валидация входных данных. Django предоставляет мощный механизм в виде Django Forms, который позволяет легко определять поля, их типы и правила валидации. Это позволяет разработчикам создавать формы, которые автоматически фильтруют и проверяют входные данные, предотвращая возможные атаки.
Вот несколько рекомендаций по использованию валидации Django Forms для повышения безопасности:
Валидация на стороне сервера. Всегда выполняйте валидацию данных на стороне сервера, даже если вы также выполняете валидацию на стороне клиента с помощью JavaScript. Валидация на стороне клиента может быть обойдена, поэтому серверная валидация является ключевым моментом для предотвращения атак и обеспечения безопасности.
Использование встроенных валидаторов. Django предоставляет ряд встроенных валидаторов для проверки различных типов данных, таких как дата, электронная почта, URL и другие. Используйте эти встроенные валидаторы в своих формах, чтобы гарантировать корректность вводимых данных и предотвратить возможные атаки на ваше приложение.
Примеры встроенных валидаторов
Django включает валидаторы для проверки электронных адресов, URL, чисел и многого другого. Рассмотрим, как использовать эти валидаторы в формах.
Создадим форму регистрации, используя различные встроенные валидаторы. Например, будем проверять корректность адреса электронной почты, URL, числового значения и даты.
Создание формы
В файле `forms.py` создадим форму с использованием встроенных валидаторов:
```python
from django import forms
from django.core.validators import EmailValidator, URLValidator, MinValueValidator, MaxValueValidator
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _
import datetime
class RegistrationForm(forms.Form):
username = forms.CharField(max_length=30, required=True)
email = forms.EmailField(validators=[EmailValidator(message=_("Введите корректный email."))], required=True)
website = forms.URLField(validators=[URLValidator(message=_("Введите корректный URL."))], required=False)
age = forms.IntegerField(validators=[MinValueValidator(18, message=_("Вам должно быть больше 18 лет")), MaxValueValidator(100, message=_("Введите корректный возраст."))], required=True)
birth_date = forms.DateField(required=True)
password = forms.CharField(widget=forms.PasswordInput, required=True)
confirm_password = forms.CharField(widget=forms.PasswordInput, required=True)
def clean_birth_date(self):
birth_date = self.cleaned_data['birth_date']
if birth_date > datetime.date.today():
raise ValidationError(_("День рождения не может быть в будущем."))
return birth_date
def clean(self):
cleaned_data = super().clean()
password = cleaned_data.get('password')
confirm_password = cleaned_data.get('confirm_password')
if password != confirm_password:
raise ValidationError(_("Пароль слишком короткий."))
return cleaned_data
```Создание представления
Создадим представление для обработки данных формы в `views.py`:
```python
from django.shortcuts import render, redirect
from django.contrib import messages
from .forms import RegistrationForm
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
# Обработка данных формы, создание нового пользователя
username = form.cleaned_data['username']
email = form.cleaned_data['email']
website = form.cleaned_data.get('website', '')
age = form.cleaned_data['age']
birth_date = form.cleaned_data['birth_date']
# Сохранение данных в базу данных или другая логика
messages.success(request, 'Регистрация прошла успешно!')
return redirect('login')
else:
messages.error(request, 'Пожалуйста, исправьте ошибки.')
else:
form = RegistrationForm()
return render(request, 'register.html', {'form': form})
```Создание шаблона
Создадим шаблон `register.html` для отображения формы регистрации:
```html
<!DOCTYPE html>
<html>
<head>
<title>Register</title>
</head>
<body>
<h1>Register</h1>
{% if messages %}
<ul class="messages">
{% for message in messages %}
<li{% if message.tags %} class="{{ message.tags }}"{% endif %}>{{ message }}</li>
{% endfor %}
</ul>
{% endif %}
<form method="post">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Регистрация</button>
</form>
</body>
</html>
```Настройка URL
Добавим маршрут для представления регистрации в `urls.py` вашего приложения:
```python
from django.urls import path
from . import views
urlpatterns = [
path('register/', views.register, name='register'),
]
```Тестирование валидации
Запустите сервер Django и перейдите к форме регистрации. Попробуйте вводить различные данные, чтобы убедиться, что встроенные валидаторы работают корректно. Например, введите неправильный адрес электронной почты, неверный URL, возраст меньше 18 или больше 100 лет и дату рождения в будущем, чтобы увидеть соответствующие сообщения об ошибках.
Пользовательские валидаторы. Для дополнительной безопасности вы можете создавать собственные пользовательские валидаторы, чтобы проверять данные на соответствие определенным требованиям. Это может включать в себя проверку на наличие специальных символов, проверку длины строки и другие пользовательские условия.
```
from django import forms
from .validators import validate_special_characters, validate_length
class RegistrationForm(forms.Form):
username = forms.CharField(
max_length=30,
required=True,
validators=[validate_length]
)
email = forms.EmailField(required=True)
password = forms.CharField(
widget=forms.PasswordInput,
required=True,
validators=[validate_special_characters, validate_length]
)
confirm_password = forms.CharField(widget=forms.PasswordInput, required=True)
def clean(self):
cleaned_data = super().clean()
password = cleaned_data.get('password')
confirm_password = cleaned_data.get('confirm_password')
if password != confirm_password:
raise ValidationError(_("Пароль не соответствует требованиям."))
return cleaned_data
```Обработка файлов. Если ваша форма позволяет загрузку файлов, убедитесь, что вы выполняете необходимые проверки безопасности для предотвращения загрузки вредоносных файлов на сервер. Это может включать в себя проверку типа файла, размера и наличие вредоносного кода в файле.
Ограничение доступа к формам. Если некоторые формы должны быть доступны только определенным пользователям или группам пользователей, убедитесь, что вы правильно настраиваете права доступа и проверяете их перед обработкой данных формы.
Отображение сообщений об ошибках без деталей. При выводе сообщений об ошибках валидации избегайте предоставления слишком подробной информации об ошибках пользователю. Это может дать злоумышленникам дополнительную информацию о вашем приложении, что может быть использовано для атак.
Обновление и проверка зависимостей. Регулярно обновляйте и проверяйте зависимости вашего приложения, включая библиотеку Django и любые сторонние библиотеки, используемые для валидации форм. Обновления могут включать исправления безопасности, которые помогут защитить ваше приложение от новых угроз.
Экранирование данных перед их выводом в шаблоны
Для предотвращения атак типа XSS (Cross-Site Scripting) важно экранировать данные перед их выводом в шаблоны. Django оснащен системой шаблонов, которая автоматически экранирует выводимые данные, обеспечивая безопасность от вредоносного внедрения JavaScript кода.
Защита от SQL-инъекций
Использование QuerySet API вместо SQL-запросов. Одним из ключевых моментов в защите от SQL-инъекций является использование Django QuerySet API вместо прямых SQL-запросов. QuerySet API позволяет строить запросы к базе данных, изолируя входные данные и автоматически применяя необходимые меры безопасности. Это предотвращает возможность внедрения вредоносных SQL-команд.
Параметризованные запросы. Еще одним важным методом предотвращения SQL-инъекций является использование параметризованных запросов. Django обеспечивает эту функциональность, позволяя передавать параметры запроса отдельно от самого запроса. Это предотвращает объединение вредоносных данных с SQL-кодом и делает атаки SQL-инъекций более сложными.
Защита cookie
Защита cookie в Django — это важная часть обеспечения безопасности вашего веб-приложения. Веб-сайты используют cookie для хранения информации, такой как сессии пользователей и предпочтения. Незащищенные cookie могут быть уязвимы для атак, таких как кража сессий и межсайтовые атаки. Вот несколько способов защиты cookie в Django:
Пример настройки безопасности cookie
1.1. SECURE_COOKIE
Используйте SECURE_COOKIE для защиты cookie с помощью флагов безопасности.
``````
# settings.py
# Устанавливает флаг HttpOnly, чтобы предотвратить доступ к cookie через JavaScript
SESSION_COOKIE_HTTPONLY = True
CSRF_COOKIE_HTTPONLY = True
# Устанавливает флаг Secure, чтобы cookie передавались только через HTTPS
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
# Устанавливает флаг SameSite, чтобы ограничить отправку cookie только на тот же сайт
SESSION_COOKIE_SAMESITE = 'Lax' # или 'Strict'
CSRF_COOKIE_SAMESITE = 'Lax' # или 'Strict'
```
- `SESSION_COOKIE_HTTPONLY` и `CSRF_COOKIE_HTTPONLY`: предотвращают доступ к cookie через JavaScript, что снижает риск межсайтового сценарного выполнения (XSS).
- `SESSION_COOKIE_SECURE` и `CSRF_COOKIE_SECURE`: обеспечивают передачу cookie только через HTTPS, что защищает от атак типа "перехват сессии".
- `SESSION_COOKIE_SAMESITE` и `CSRF_COOKIE_SAMESITE`: ограничивают отправку cookie только в контексте того же сайта, что предотвращает межсайтовые атаки (например, CSRF).
# settings.py
# Устанавливает флаг HttpOnly, чтобы предотвратить доступ к cookie через JavaScript
SESSION_COOKIE_HTTPONLY = True
CSRF_COOKIE_HTTPONLY = True
# Устанавливает флаг Secure, чтобы cookie передавались только через HTTPS
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
# Устанавливает флаг SameSite, чтобы ограничить отправку cookie только на тот же сайт
SESSION_COOKIE_SAMESITE = 'Lax' # или 'Strict'
CSRF_COOKIE_SAMESITE = 'Lax' # или 'Strict'
```
- `SESSION_COOKIE_HTTPONLY` и `CSRF_COOKIE_HTTPONLY`: предотвращают доступ к cookie через JavaScript, что снижает риск межсайтового сценарного выполнения (XSS).
- `SESSION_COOKIE_SECURE` и `CSRF_COOKIE_SECURE`: обеспечивают передачу cookie только через HTTPS, что защищает от атак типа "перехват сессии".
- `SESSION_COOKIE_SAMESITE` и `CSRF_COOKIE_SAMESITE`: ограничивают отправку cookie только в контексте того же сайта, что предотвращает межсайтовые атаки (например, CSRF).2. Регулярная смена сессионных ключей
Регулярная смена сессионных ключей может помочь снизить риск кражи сессий. Вы можете установить срок действия сессии.
```
# settings.py
# Устанавливает срок действия сессии в секундах
SESSION_COOKIE_AGE = 1209600 # 2 недели
# Устанавливает срок действия cookie CSRF токена в секундах
CSRF_COOKIE_AGE = 31449600 # 1 год
```3. Обработка тайм-аута сессии
Убедитесь, что сессии истекают после определенного периода неактивности.
```
# settings.py
# Устанавливает, что сессия истекает при закрытии браузера
SESSION_EXPIRE_AT_BROWSER_CLOSE = True
# Устанавливает срок действия сессии в секундах
SESSION_COOKIE_AGE = 1800 # 30 минут
```4. Использование подписанных cookie
Django поддерживает подписанные cookie, которые могут быть использованы для хранения данных, которые нельзя изменять на стороне клиента.
```
# settings.py
# Cookie Security Settings
SESSION_COOKIE_HTTPONLY = True
CSRF_COOKIE_HTTPONLY = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SESSION_COOKIE_SAMESITE = 'Lax'
CSRF_COOKIE_SAMESITE = 'Lax'
# Session Settings
SESSION_EXPIRE_AT_BROWSER_CLOSE = True
SESSION_COOKIE_AGE = 1800 # 30 минут
# CSRF Middleware
MIDDLEWARE = [
...,
'django.middleware.csrf.CsrfViewMiddleware',
...,
]
```
```
# myapp/utils.py
from django.core import signing
from django.conf import settings
def set_signed_cookie(response, key, value, max_age=None):
signed_value = signing.dumps(value)
response.set_cookie(key, signed_value, max_age=max_age, httponly=True, secure=True, samesite='Lax')
def get_signed_cookie(request, key, default=None):
signed_value = request.COOKIES.get(key)
if not signed_value:
return default
try:
return signing.loads(signed_value)
except signing.BadSignature:
return default
```Часть 4. Защита от DDos-атак
Защита от DDoS-атак (распределенных атак типа "отказ в обслуживании") является важной частью обеспечения безопасности любого веб-приложения. Django, как и другие веб-фреймворки, может быть уязвим к таким атакам, но существуют различные методы и инструменты, которые можно использовать для уменьшения риска и минимизации воздействия DDoS-атак.
Основные методы защиты от DDoS-атак
1. Использование веб-аппликейшен фаерволов (WAF):
- WAF может помочь защитить ваше приложение от различных атак, включая DDoS, блокируя подозрительный трафик до того, как он достигнет вашего сервера.
- Примеры: AWS WAF, Cloudflare, Imperva, Akamai.
2. Использование CDN (Content Delivery Network):
- CDN распределяет нагрузку между несколькими серверами и кэширует содержимое вашего сайта, уменьшая нагрузку на основной сервер.
- Примеры: Cloudflare, AWS CloudFront, Akamai, Fastly.
3. Ограничение скорости запросов (Rate Limiting):
- Ограничение скорости запросов помогает предотвратить злоупотребление вашим сервером путем ограничения количества запросов, которые могут быть сделаны с одного IP-адреса за определенный период времени.
- В Django можно использовать такие библиотеки, как django-ratelimit.
4. Настройка сервера:
- Оптимизация настроек сервера (например, nginx, Apache) для обработки большого количества запросов.
- Использование инструментов для блокировки вредоносных IP-адресов (например, fail2ban).
5. Мониторинг и автоматическое реагирование:
- Регулярный мониторинг трафика и автоматическое реагирование на аномальные всплески активности.
- Использование инструментов мониторинга, таких как Prometheus, Grafana, ELK Stack (Elasticsearch, Logstash, Kibana).
Примеры реализации некоторых методов
1. Ограничение скорости запросов с использованием django-ratelimit
Установите библиотеку django-ratelimit:
pip install django-ratelimitНастройте middleware и используйте декоратор ratelimit для ограничения скорости запросов:
# settings.py
MIDDLEWARE = [
...,
'django_ratelimit.middleware.RatelimitMiddleware',
...,
]
# views.py
from django_ratelimit.decorators import ratelimit
from django.http import HttpResponse
@ratelimit(key='ip', rate='5/m', method='POST', block=True)
def my_view(request):
return HttpResponse('This is my view response')2. Настройка веб-сервера (nginx) для защиты от DDoS
Настройка ограничений на уровне сервера для nginx:
http {
...
limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;
limit_conn_zone $binary_remote_addr zone=addr:10m;
server {
...
location / {
limit_req zone=one burst=5 nodelay;
limit_conn addr 10;
...
}
}
}Использование специализированных сервисов для защиты от DDoS
Для более качественной защиты можно использовать специализированные сервисы, такие как Cloudflare, Kaspersky DDoS Protection и.т.п. Это минимизирует влияние DDoS-атак, обеспечивая постоянную доступность всей инфраструктуры и важнейших онлайн-ресурсов. Непрерывный анализ трафика, оповещения о возможных атаках, перенаправление трафика в центры очистки и возврат очищенного трафика в сеть, – решение включает все необходимое для защиты от любых видов DDoS-атак и уменьшения их последствий
Защита от DDoS-атак требует комплексного подхода, включающего использование различных инструментов и методов для снижения риска и минимизации воздействия атак. Использование WAF, CDN, ограничение скорости запросов, настройка сервера и мониторинг трафика — все это важные компоненты защиты вашего Django-приложения.
Дополнительные ресурсы и ссылки
Официальная документация Django по безопасности. Здесь собрана информация о встроенных механизмах безопасности Django, рекомендации по их использованию и актуальные советы по предотвращению угроз.
Рекомендации по безопасности веб-приложений на Python. Проект OWASP, посвященный безопасности при разработке на Python. Содержит рекомендации, советы и инструменты для обеспечения безопасности в Python-приложениях.
Top 10 OWASP. Список наиболее критичных уязвимостей в веб-приложениях.
Mozilla Web Security Guidelines. Рекомендации от Mozilla по безопасности веб-приложений. Включает в себя советы по различным аспектам безопасности, таким как HTTPS, Content Security Policy и другие.
The Web Application Security Consortium (WASC). Организация, занимающаяся разработкой стандартов и рекомендаций по безопасности веб-приложений. Их ресурсы включают в себя статьи, учебные пособия и инструменты для обеспечения безопасности веб-разработки.
natrium
Настройки "LOGIN_ATTEMPTS_LIMIT" и "LOGIN_ATTEMPTS_TIMEOUT" - это, кажется, уже не ванильная Django, в доках такого нет