Чеклист безопасности Django перед продакшеном

TL;DR

Безопасность Django-приложения — это многоуровневая защита. Ключевые моменты:

• Django защищает из коробки: XSS, CSRF, SQL Injection, Clickjacking
• Но нужна правильная настройка: DEBUG=False, HTTPS, SECRET_KEY из env
• OWASP Top 10 coverage: Все критичные уязвимости покрыты при правильной конфигурации
• Регулярные обновления: 80% уязвимостей — в зависимостях
• Мониторинг обязателен: Sentry + django-axes для детекции атак

Результат: Защищенное приложение, готовое к audit и compliance проверкам.

Введение

Django имеет отличную репутацию в области безопасности благодаря встроенной защите от большинства OWASP Top 10 уязвимостей. Однако, неправильная конфигурация может свести все это на нет.

Статистика:

95% успешных атак на Django-приложения происходят из-за misconfiguration, а не из-за уязвимостей в самом фреймворке. — OWASP Report 2023

В этой статье — полный security checklist с примерами реальных атак и методами защиты.

OWASP Top 10 в контексте Django

1. SECRET_KEY — основа криптографии Django

Что это и зачем

SECRET_KEY используется для:

• Подписи сессий (session cookies)
• CSRF токенов
• Подписи данных (signing module)
• Password reset tokens

Если SECRET_KEY утекёт → атакующий может:

• Подделать сессии любого пользователя
• Обойти CSRF защиту
• Создать валидные password reset ссылки

Правильная настройка

# ❌ ОПАСНО! Никогда так не делайте
SECRET_KEY = 'django-insecure-hardcoded-key-123456'

# ❌ ОПАСНО! В коде
SECRET_KEY = '7d@kw!_x9%m&2v8n#p$q^r*s+t=u'

# ✅ ПРАВИЛЬНО: Из переменных окружения
import os
from django.core.exceptions import ImproperlyConfigured

SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')

if not SECRET_KEY:
    raise ImproperlyConfigured(
        "DJANGO_SECRET_KEY environment variable must be set"
    )

# ✅ Или с django-environ
import environ
env = environ.Env()
SECRET_KEY = env('SECRET_KEY')  # Raises error if not set

Генерация нового ключа

# Способ 1: Django utility
python -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'

# Способ 2: OpenSSL
openssl rand -base64 50

# Способ 3: Python secrets module
python -c 'import secrets; print(secrets.token_urlsafe(50))'

Ротация SECRET_KEY

Если ключ скомпрометирован:

# settings.py
SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')
# Старый ключ для валидации существующих токенов
SECRET_KEY_FALLBACKS = [
    os.environ.get('DJANGO_SECRET_KEY_OLD'),
]

# После ротации все сессии будут инвалидированы
# Пользователи должны войти заново

⚠️ Важно: После смены SECRET_KEY:

• Все сессии станут невалидными
• CSRF токены перестанут работать
• Password reset ссылки станут недействительны

Результат: Основа для всех cryptographic операций защищена.

2. DEBUG = False в Production

Почему DEBUG=True опасно

При DEBUG=True Django показывает:

1. Детальные tracebacks с:

   • Структурой БД (таблицы, колонки)
   • Путями к файлам на сервере
   • Значениями переменных (могут быть пароли!)
   • Версиями библиотек

2. Настройки проекта (settings.py)

3. SQL-запросы с данными

4. Стек вызовов с логикой приложения

Реальный пример утечки

# views.py
def user_profile(request, user_id):
    api_key = "sk-proj-1234567890"  # API ключ в коде
    user = User.objects.get(id=user_id)
    # ...

При ошибке с DEBUG=True:

Local vars:
    api_key = 'sk-proj-1234567890'  # ← УТЕКАЕТ!
    user_id = 42

Правильная настройка

# settings.py
DEBUG = os.environ.get('DJANGO_DEBUG', 'False') == 'True'

# Альтернатива: явный production режим
ENVIRONMENT = os.environ.get('ENVIRONMENT', 'production')
DEBUG = ENVIRONMENT == 'development'

# ОБЯЗАТЕЛЬНО при DEBUG=False
ALLOWED_HOSTS = [
    'yourdomain.com',
    'www.yourdomain.com',
    '.yourdomain.com',  # Все поддомены
]

# Для production
if not DEBUG:
    # Обязательно настройте error handling
    ADMINS = [('Admin Name', 'admin@yourdomain.com')]
    SERVER_EMAIL = 'error@yourdomain.com'

    # Custom error pages
    TEMPLATES[0]['OPTIONS']['debug'] = False

Custom error pages

# urls.py
handler400 = 'myapp.views.bad_request'
handler403 = 'myapp.views.permission_denied'
handler404 = 'myapp.views.page_not_found'
handler500 = 'myapp.views.server_error'

# views.py
from django.shortcuts import render

def page_not_found(request, exception):
    return render(request, '404.html', status=404)

def server_error(request):
    return render(request, '500.html', status=500)

Результат: Атакующий не получает информацию о структуре приложения.

3. HTTPS Everywhere

Почему HTTPS обязателен

Без HTTPS атакующий может:

• Перехватить сессионные cookies (session hijacking)
• Прочитать передаваемые данные (пароли, личная информация)
• Модифицировать ответы сервера (man-in-the-middle)

Полная конфигурация HTTPS

# settings.py (только для production!)
if not DEBUG:
    # 1. Редирект всех HTTP → HTTPS
    SECURE_SSL_REDIRECT = True

    # 2. Для проксирующих серверов (nginx, CloudFlare, AWS ALB)
    SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')

    # 3. Secure cookies (HTTPS only)
    SESSION_COOKIE_SECURE = True
    CSRF_COOKIE_SECURE = True

    # 4. HSTS (HTTP Strict Transport Security)
    SECURE_HSTS_SECONDS = 31536000  # 1 год
    SECURE_HSTS_INCLUDE_SUBDOMAINS = True
    SECURE_HSTS_PRELOAD = True  # Для включения в HSTS preload list

    # 5. Дополнительные настройки cookies
    SESSION_COOKIE_HTTPONLY = True  # Защита от XSS
    CSRF_COOKIE_HTTPONLY = True
    SESSION_COOKIE_SAMESITE = 'Lax'  # Защита от CSRF
    CSRF_COOKIE_SAMESITE = 'Lax'

HSTS Preload

Что это: Браузеры предзагружают список сайтов, которые ВСЕГДА должны открываться через HTTPS.

Как добавить сайт:

1. Настройте SECURE_HSTS_PRELOAD = True
2. Убедитесь, что HSTS работает минимум 18 недель
3. Подайте заявку: https://hstspreload.org/

⚠️ Важно: Удаление из preload list может занять месяцы!

Let's Encrypt для бесплатного SSL

# Установка Certbot
sudo apt install certbot python3-certbot-nginx

# Автоматическая настройка для nginx
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

# Автопродление (добавится в cron)
sudo certbot renew --dry-run

Проверка конфигурации

# Django check
python manage.py check --deploy

# SSL Labs test (A+ rating)
# https://www.ssllabs.com/ssltest/analyze.html?d=yourdomain.com

# Mozilla Observatory
# https://observatory.mozilla.org/

Результат: Все данные передаются в зашифрованном виде.

4. CSRF Protection

Как работает CSRF атака

Сценарий:

1. Пользователь авторизован на bank.com
2. Открывает злонамеренный сайт evil.com
3. evil.com содержит:

<form action="https://bank.com/transfer" method="POST">
  <input name="to" value="attacker_account">
  <input name="amount" value="10000">
</form>
<script>document.forms[0].submit();</script>

1. Браузер автоматически отправляет cookies (сессию)
2. Деньги переведены без ведома пользователя!

Django защита

# settings.py - CSRF middleware включён по умолчанию
MIDDLEWARE = [
    # ...
    'django.middleware.csrf.CsrfViewMiddleware',  # ← Обязательно!
    # ...
]

В шаблонах

<form method="post">
    {% csrf_token %}  {# ← ОБЯЗАТЕЛЬНО в каждой POST форме #}
    <input type="text" name="username">
    <button type="submit">Submit</button>
</form>

В AJAX запросах

// Получить CSRF token из cookie
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');

// Fetch API
fetch('/api/endpoint/', {
    method: 'POST',
    headers: {
        'X-CSRFToken': csrftoken,
        'Content-Type': 'application/json',
    },
    body: JSON.stringify(data)
})

// Или установить глобально для всех запросов
// (если используете axios или другую библиотеку)
axios.defaults.headers.common['X-CSRFToken'] = csrftoken;

Когда можно отключить CSRF

from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator

# ❌ ОПАСНО! Используйте только для:
# 1. Публичных API без авторизации
# 2. Webhook endpoints (с другой аутентификацией)

@csrf_exempt
def webhook_receiver(request):
    # ОБЯЗАТЕЛЬНО проверить подпись webhook!
    signature = request.headers.get('X-Hub-Signature')
    if not verify_signature(request.body, signature):
        return HttpResponseForbidden()
    # ...

# Для class-based views
@method_decorator(csrf_exempt, name='dispatch')
class WebhookView(View):
    def post(self, request):
        # ...

Дополнительные настройки CSRF

# settings.py

# Доверенные origins для CSRF (для CORS requests)
CSRF_TRUSTED_ORIGINS = [
    'https://yourdomain.com',
    'https://*.yourdomain.com',
]

# Кастомный header name
CSRF_HEADER_NAME = 'HTTP_X_CSRFTOKEN'

# Cookie settings
CSRF_COOKIE_NAME = 'csrftoken'
CSRF_COOKIE_AGE = 31449600  # 1 год
CSRF_COOKIE_DOMAIN = '.yourdomain.com'  # Для поддоменов
CSRF_COOKIE_PATH = '/'
CSRF_COOKIE_SECURE = True  # HTTPS only
CSRF_COOKIE_HTTPONLY = True  # Защита от XSS
CSRF_COOKIE_SAMESITE = 'Lax'  # Strict или Lax

Результат: Защита от подделки запросов со сторонних сайтов.

5. SQL Injection — почему ORM не панацея

Безопасно: ORM

# ✅ БЕЗОПАСНО - параметризованные запросы
username = request.GET.get('username')
users = User.objects.filter(username=username)

# ✅ БЕЗОПАСНО - Q objects
from django.db.models import Q
User.objects.filter(
    Q(username=username) | Q(email=email)
)

# ✅ БЕЗОПАСНО - даже со строками
User.objects.filter(username__contains=user_input)

SQL под капотом:

SELECT * FROM auth_user
WHERE username = %s  -- Параметр экранирован!

Опасно: Raw SQL

# ❌ ОПАСНО! SQL Injection
username = request.GET.get('username')
User.objects.raw(
    f"SELECT * FROM auth_user WHERE username = '{username}'"
)

# Атака: ?username=' OR '1'='1
# Результат: SELECT * FROM auth_user WHERE username = '' OR '1'='1'
# → Вернёт ВСЕХ пользователей!

Правильное использование Raw SQL

# ✅ БЕЗОПАСНО - параметризованный запрос
User.objects.raw(
    "SELECT * FROM auth_user WHERE username = %s",
    [username]  # ← Параметр экранируется
)

# ✅ БЕЗОПАСНО - с cursor
from django.db import connection

with connection.cursor() as cursor:
    cursor.execute(
        "SELECT * FROM auth_user WHERE username = %s AND active = %s",
        [username, True]
    )
    results = cursor.fetchall()

Опасность в extra() и raw()

# ❌ ОПАСНО!
User.objects.extra(
    where=[f"username = '{user_input}'"]
)

# ✅ БЕЗОПАСНО
User.objects.extra(
    where=["username = %s"],
    params=[user_input]
)

NoSQL Injection (MongoDB, etc.)

# Даже с NoSQL ORM нужна осторожность
# ❌ ОПАСНО (если используете djongo или mongoengine)
filter_query = json.loads(request.body)  # Пользовательский ввод!
Document.objects.filter(**filter_query)  # Может содержать $where, $ne, etc.

# ✅ БЕЗОПАСНО - валидация структуры
allowed_fields = ['username', 'email', 'age']
filter_query = {
    k: v for k, v in user_input.items()
    if k in allowed_fields
}

Результат: БД защищена от injection атак.

6. XSS (Cross-Site Scripting)

Типы XSS

Django автоматическая защита

{# ✅ БЕЗОПАСНО - автоэкранирование #}
<p>Hello, {{ user.username }}!</p>

{# Если username = "<script>alert('XSS')</script>" #}
{# Результат: <p>Hello, &lt;script&gt;alert('XSS')&lt;/script&gt;!</p> #}

Когда отключается экранирование

{# ❌ ОПАСНО! |safe отключает экранирование #}
{{ user_comment|safe }}

{# ❌ ОПАСНО! #}
{% autoescape off %}
    {{ user_input }}
{% endautoescape %}

{# ✅ Используйте safe только для доверенного контента #}
{# Например, markdown после санитизации: #}
{{ content|markdown|safe }}

Санитизация HTML

# Установка
pip install bleach

# Использование
import bleach

ALLOWED_TAGS = ['p', 'br', 'strong', 'em', 'a']
ALLOWED_ATTRS = {'a': ['href', 'title']}

def sanitize_html(dirty_html):
    return bleach.clean(
        dirty_html,
        tags=ALLOWED_TAGS,
        attributes=ALLOWED_ATTRS,
        strip=True  # Удалить запрещённые теги
    )

# В view
clean_comment = sanitize_html(request.POST.get('comment'))
comment.content = clean_comment
comment.save()

JSON и JavaScript context

{# ❌ ОПАСНО! #}
<script>
    var userData = {{ user_data|safe }};  // XSS если в user_data есть </script>
</script>

{# ✅ БЕЗОПАСНО - используйте json_script #}
{{ user_data|json_script:"user-data" }}
<script>
    const userData = JSON.parse(
        document.getElementById('user-data').textContent
    );
</script>

Content Security Policy (CSP)

# pip install django-csp

# settings.py
MIDDLEWARE = [
    # ...
    'csp.middleware.CSPMiddleware',
]

# CSP политика
CSP_DEFAULT_SRC = ("'self'",)
CSP_SCRIPT_SRC = (
    "'self'",
    'https://cdn.jsdelivr.net',  # Trusted CDN
)
CSP_STYLE_SRC = (
    "'self'",
    "'unsafe-inline'",  # Только если необходимо
)
CSP_IMG_SRC = ("'self'", 'data:', 'https:')
CSP_FONT_SRC = ("'self'", 'https://fonts.gstatic.com')
CSP_CONNECT_SRC = ("'self'", 'https://api.yourdomain.com')

# Reporting
CSP_REPORT_URI = '/csp-report/'
CSP_REPORT_ONLY = False  # True для тестирования

# views.py - CSP report endpoint
@csrf_exempt
def csp_report(request):
    if request.method == 'POST':
        logger.warning('CSP Violation: %s', request.body)
    return HttpResponse()

Результат: XSS атаки блокируются на всех уровнях.

7. Аутентификация и Session Security

Password Hashing

# settings.py
PASSWORD_HASHERS = [
    'django.contrib.auth.hashers.Argon2PasswordHasher',  # Самый стойкий
    'django.contrib.auth.hashers.PBKDF2PasswordHasher',  # По умолчанию
    'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher',
    'django.contrib.auth.hashers.BCryptSHA256PasswordHasher',
]

# Для Argon2
# pip install django[argon2]

Password Validation

# settings.py
AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
        'OPTIONS': {
            'min_length': 12,  # Минимум 12 символов
        }
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
    # Кастомный валидатор
    {
        'NAME': 'myapp.validators.PasswordComplexityValidator',
    },
]

# myapp/validators.py
import re
from django.core.exceptions import ValidationError

class PasswordComplexityValidator:
    def validate(self, password, user=None):
        if not re.search(r'[A-Z]', password):
            raise ValidationError("Password must contain uppercase letter")
        if not re.search(r'[a-z]', password):
            raise ValidationError("Password must contain lowercase letter")
        if not re.search(r'[0-9]', password):
            raise ValidationError("Password must contain digit")
        if not re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
            raise ValidationError("Password must contain special character")

    def get_help_text(self):
        return "Password must contain uppercase, lowercase, digit, and special character"

Brute-Force Protection

# pip install django-axes

# settings.py
INSTALLED_APPS = [
    # ...
    'axes',
]

MIDDLEWARE = [
    # AxesMiddleware должен быть ПОСЛЕ AuthenticationMiddleware
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'axes.middleware.AxesMiddleware',
]

AUTHENTICATION_BACKENDS = [
    'axes.backends.AxesStandaloneBackend',  # AxesBackend первым!
    'django.contrib.auth.backends.ModelBackend',
]

# Настройки Axes
AXES_FAILURE_LIMIT = 5  # Блокировка после 5 неудачных попыток
AXES_COOLOFF_TIME = 1  # Час блокировки
AXES_LOCKOUT_MESSAGE = 'Too many failed attempts. Try again later.'
AXES_RESET_ON_SUCCESS = True  # Сброс счётчика после успешного входа
AXES_LOCK_OUT_BY_COMBINATION_USER_AND_IP = True  # По user + IP

# Whitelist IP
AXES_IP_WHITELIST = ['127.0.0.1']
AXES_NEVER_LOCKOUT_WHITELIST = True

# Blacklist
AXES_IP_BLACKLIST = []
AXES_ONLY_USER_FAILURES = False  # False = по IP тоже блокирует

Two-Factor Authentication (2FA)

# pip install django-otp qrcode

# settings.py
INSTALLED_APPS = [
    # ...
    'django_otp',
    'django_otp.plugins.otp_totp',
]

MIDDLEWARE = [
    # ...
    'django_otp.middleware.OTPMiddleware',
]

# views.py
from django_otp.decorators import otp_required

@otp_required
def sensitive_view(request):
    # Требует 2FA
    pass

# Для админки
from django_otp.admin import OTPAdminSite
admin.site.__class__ = OTPAdminSite

Session Security

# settings.py

# Session настройки
SESSION_COOKIE_AGE = 1209600  # 2 недели
SESSION_SAVE_EVERY_REQUEST = False  # True = обновлять при каждом запросе
SESSION_EXPIRE_AT_BROWSER_CLOSE = False  # True = сессия только на время браузера

# Security
SESSION_COOKIE_HTTPONLY = True  # Защита от XSS
SESSION_COOKIE_SECURE = True  # HTTPS only
SESSION_COOKIE_SAMESITE = 'Lax'  # Strict, Lax, или None

# Session backend (Redis для production)
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'

# Или полностью в Redis
# pip install django-redis
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
SESSION_CACHE_ALIAS = 'default'

Результат: Многоуровневая защита учётных записей.

8. File Upload Security

Опасности загрузки файлов

1. Remote Code Execution: Загрузка .php, .py, .jsp на сервер
2. Path Traversal: ../../etc/passwd в имени файла
3. XSS: Загрузка HTML/SVG с JavaScript
4. DoS: Огромные файлы
5. Malware: Вирусы в файлах

Валидация типов файлов

# models.py
from django.core.exceptions import ValidationError
import os
import magic  # python-magic

ALLOWED_EXTENSIONS = ['.pdf', '.jpg', '.jpeg', '.png', '.doc', '.docx']
ALLOWED_MIMETYPES = [
    'application/pdf',
    'image/jpeg',
    'image/png',
    'application/msword',
]

def validate_file_extension(value):
    ext = os.path.splitext(value.name)[1].lower()
    if ext not in ALLOWED_EXTENSIONS:
        raise ValidationError(
            f'Unsupported file extension. Allowed: {", ".join(ALLOWED_EXTENSIONS)}'
        )

def validate_file_mimetype(value):
    # ВНИМАНИЕ: Не доверяйте только расширению!
    # Проверяйте реальный MIME type
    file_mime = magic.from_buffer(value.read(1024), mime=True)
    value.seek(0)  # Вернуть указатель в начало

    if file_mime not in ALLOWED_MIMETYPES:
        raise ValidationError(f'Invalid file type: {file_mime}')

def validate_file_size(value):
    filesize = value.size
    if filesize > 5 * 1024 * 1024:  # 5MB
        raise ValidationError('Max file size is 5MB')

class Document(models.Model):
    upload = models.FileField(
        upload_to='documents/%Y/%m/%d/',
        validators=[
            validate_file_extension,
            validate_file_mimetype,
            validate_file_size,
        ]
    )

Безопасное имя файла

# Никогда не используйте оригинальное имя напрямую!
import uuid
from django.utils.text import slugify

def secure_filename(filename):
    # Удалить путь
    filename = os.path.basename(filename)
    # Slugify имени
    name, ext = os.path.splitext(filename)
    name = slugify(name)
    # Добавить UUID для уникальности
    return f"{name}-{uuid.uuid4().hex[:8]}{ext}"

# В модели
def upload_path(instance, filename):
    return f'uploads/{instance.user.id}/{secure_filename(filename)}'

class Document(models.Model):
    file = models.FileField(upload_to=upload_path)

Ограничения на уровне Django

# settings.py

# Максимальный размер загружаемых данных
DATA_UPLOAD_MAX_MEMORY_SIZE = 5242880  # 5MB в памяти
FILE_UPLOAD_MAX_MEMORY_SIZE = 5242880  # 5MB в памяти

# Временные файлы
FILE_UPLOAD_TEMP_DIR = '/tmp/django-uploads'
FILE_UPLOAD_PERMISSIONS = 0o644

# Хранение файлов вне MEDIA_ROOT для исполняемых
PRIVATE_MEDIA_ROOT = '/var/app/private-media/'

Сканирование на вирусы

# pip install pyclamd

import pyclamd

def scan_uploaded_file(file):
    cd = pyclamd.ClamdUnixSocket()

    # Проверить что ClamAV доступен
    if not cd.ping():
        raise Exception('ClamAV is not running')

    # Сканировать файл
    scan_result = cd.scan_stream(file.read())
    file.seek(0)

    if scan_result:
        raise ValidationError('File contains malware!')

# В view или form
def clean_file(self):
    file = self.cleaned_data.get('file')
    scan_uploaded_file(file)
    return file

CDN и изоляция

# settings.py - Хранить загрузки отдельно
AWS_S3_CUSTOM_DOMAIN = f'{AWS_STORAGE_BUCKET_NAME}.s3.amazonaws.com'
MEDIA_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/media/'

# Отдельный bucket для пользовательских загрузок
USER_UPLOADS_BUCKET = 'user-uploads-isolated'

# Content-Disposition для скачивания вместо отображения
AWS_S3_OBJECT_PARAMETERS = {
    'ContentDisposition': 'attachment',  # Принудительное скачивание
}

Результат: Загрузки файлов не создают уязвимостей.

9. Security Headers

# settings.py

# X-Frame-Options (защита от clickjacking)
X_FRAME_OPTIONS = 'DENY'  # Или 'SAMEORIGIN'

# X-Content-Type-Options
SECURE_CONTENT_TYPE_NOSNIFF = True

# X-XSS-Protection (legacy, но всё ещё полезен)
SECURE_BROWSER_XSS_FILTER = True

# Referrer-Policy
SECURE_REFERRER_POLICY = 'strict-origin-when-cross-origin'
# Опции: no-referrer, origin, strict-origin, etc.

# Permissions-Policy (ранее Feature-Policy)
PERMISSIONS_POLICY = {
    "geolocation": [],  # Отключить для всех
    "camera": [],
    "microphone": [],
    "payment": ["self"],  # Только для своего origin
}

Кастомный middleware для headers

# middleware.py
class SecurityHeadersMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)

        # Permissions-Policy
        response['Permissions-Policy'] = 'geolocation=(), camera=(), microphone=()'

        # Expect-CT (Certificate Transparency)
        response['Expect-CT'] = 'max-age=86400, enforce'

        # NEL (Network Error Logging)
        response['NEL'] = '{"report_to":"default","max_age":31536000}'

        return response

# settings.py
MIDDLEWARE = [
    'myapp.middleware.SecurityHeadersMiddleware',
    # ...
]

Результат: Браузеры применяют дополнительные защитные механизмы.

10. Dependencies Security

Регулярная проверка уязвимостей

# pip-audit (официальный инструмент от PyPA)
pip install pip-audit
pip-audit

# Safety
pip install safety
safety check

# С GitHub Advisory Database
safety check --json

# Snyk (более продвинутый)
npm install -g snyk
snyk test --file=requirements.txt

Автоматизация в CI/CD

# .github/workflows/security.yml
name: Security Check

on: [push, pull_request]

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          pip install pip-audit safety

      - name: Run pip-audit
        run: pip-audit --requirement requirements.txt

      - name: Run safety check
        run: safety check --file requirements.txt --json

      - name: Run bandit (code security)
        run: |
          pip install bandit
          bandit -r . -f json -o bandit-report.json

Dependabot configuration

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "pip"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10
    reviewers:
      - "security-team"
    labels:
      - "security"
      - "dependencies"

Результат: Уязвимости в зависимостях детектируются автоматически.

Финальный Production Checklist

Критически важно (нельзя игнорировать)

• ✅ DEBUG = False
• ✅ SECRET_KEY из environment variables
• ✅ ALLOWED_HOSTS настроен корректно
• ✅ HTTPS настроен с валидным сертификатом
• ✅ SESSION_COOKIE_SECURE = True
• ✅ CSRF_COOKIE_SECURE = True
• ✅ SECURE_SSL_REDIRECT = True
• ✅ python manage.py check --deploy без ошибок
• ✅ Все credentials в .env (не в коде!)
• ✅ Database user с минимальными привилегиями

Обязательно (сильно рекомендуется)

• ✅ HSTS настроен (SECURE_HSTS_SECONDS)
• ✅ CSP (Content Security Policy) активен
• ✅ File upload validation
• ✅ Rate limiting (django-axes или django-ratelimit)
• ✅ Logging настроен корректно
• ✅ Error monitoring (Sentry)
• ✅ Regular backups (автоматические)
• ✅ pip-audit в CI/CD pipeline

Настоятельно рекомендуется

• ✅ WAF (Web Application Firewall) - CloudFlare, AWS WAF
• ✅ 2FA для администраторов
• ✅ Penetration testing (ежегодно)
• ✅ Security code review process
• ✅ Secrets scanning в Git (git-secrets, truffleHog)
• ✅ GDPR/CCPA compliance (если applicable)
• ✅ Security.txt (/.well-known/security.txt)
• ✅ Bug bounty program (для крупных проектов)

Автоматизация проверок

Django check --deploy

# Запустить все security проверки
python manage.py check --deploy

# Пример вывода предупреждений:
# WARNINGS:
# ?: (security.W004) You have not set a value for the SECURE_HSTS_SECONDS setting.
# ?: (security.W008) Your SECURE_SSL_REDIRECT setting is not set to True.
# ?: (security.W012) SESSION_COOKIE_SECURE is not set to True.

Pre-commit hooks

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/pycqa/bandit
    rev: '1.7.5'
    hooks:
      - id: bandit
        args: ['-r', 'myapp/', '-f', 'screen']

  - repo: https://github.com/PyCQA/flake8
    rev: '6.1.0'
    hooks:
      - id: flake8
        additional_dependencies: [flake8-bugbear, flake8-security]

# Установка
pip install pre-commit
pre-commit install

Инструменты и ресурсы

Обязательные инструменты

• django-axes — Brute-force protection
• django-csp — Content Security Policy
• pip-audit — Vulnerability scanning
• bandit — Code security linter
• safety — Dependency checker

Сканеры и тестирование

• OWASP ZAP — Automated security testing
• Burp Suite — Professional security testing
• Nikto — Web server scanner
• SQLMap — SQL injection testing

Мониторинг

• Sentry — Error & security monitoring
• DataDog — APM & security
• Wazuh — Security monitoring & threat detection

Образовательные ресурсы

• OWASP Top 10
• Django Security Releases
• PortSwigger Web Security Academy
• Mozilla Web Security

Compliance и Regulations

GDPR (EU)

# Право на забвение (Right to be forgotten)
class User(AbstractUser):
    def anonymize(self):
        """GDPR compliant user anonymization"""
        self.email = f"deleted_{self.id}@example.com"
        self.first_name = "Deleted"
        self.last_name = "User"
        self.is_active = False
        self.save()

        # Удалить или анонимизировать связанные данные
        self.profile.delete()
        self.comments.all().update(content="[deleted]")

# Data export
def export_user_data(user):
    """GDPR compliant data export"""
    return {
        'profile': UserSerializer(user).data,
        'comments': CommentSerializer(user.comments.all(), many=True).data,
        'orders': OrderSerializer(user.orders.all(), many=True).data,
    }

PCI DSS (Payment Card Industry)

# НИКОГДА не храните:
# - Полный номер карты (только last 4 digits)
# - CVV/CVC
# - PIN

class Payment(models.Model):
    # ✅ Только последние 4 цифры
    card_last4 = models.CharField(max_length=4)

    # ✅ Токен от payment gateway (Stripe, etc.)
    payment_token = models.CharField(max_length=255)

    # ❌ НИКОГДА так не делайте!
    # card_number = models.CharField(max_length=16)  # ЗАПРЕЩЕНО!
    # cvv = models.CharField(max_length=3)  # ЗАПРЕЩЕНО!

Заключение

Безопасность Django-приложения — это не чек-лист, который можно пройти один раз. Это непрерывный процесс:

1. Проектирование: Security by design
2. Разработка: Secure coding practices
3. Тестирование: Automated security tests
4. Деплой: Hardened configuration
5. Мониторинг: Real-time threat detection
6. Обновление: Regular patches and updates

Ключевые принципы:

• Defense in Depth: Многоуровневая защита
• Least Privilege: Минимальные права доступа
• Fail Securely: Безопасный режим при ошибках
• Don't Trust Input: Валидация всех данных
• Keep it Simple: Простота = безопасность

Помните:

"Безопасность — это цепь. Она настолько сильна, насколько сильно её самое слабое звено."

Начните с python manage.py check --deploy и исправьте все предупреждения. Остальное приложится!