DRF captcha своими руками

Пришла мне тут по работе задача сделать возможность добавления товара в корзину пользователем без авторизации. Корзина, причем должна храниться на бэке для того, чтобы можно было проводить аналитику по неоформленным заказам, а также, если пользователь авторизуется, то добавлять эту корзину к его профилю для доступности ее с любых других устройств, на которых он (пользователь авторизован).
Ясное дело, что для корзины одного пользователя в сеансе оформления заказа нужен уникальный идентификатор, по которому можно определить в какую “корзину” поместить товар.
Так как на проекте мы использует REST подход к проектированию API, я подумал, что можно генерировать uuid ключ на клиенте и передавать его при каждом запросе добавления товара в корзину.
Да, все бы хорошо, но возникает потенциальная проблема паразитных запросов от недоброжелателей. Да, безусловно, есть куча всяких способов защититься от троттлинга, но все это кажется мне в этой ситуации не совсем уместным. Поэтому, я решил, что лучше уникальный идентификатор генерировать на бэкенде, а выдавать его при прохождении CAPTCHA.

Поиск готовых решений

На проекте используется Django 5.x и Django Rest Framework. Я начал поиск готовых библиотек, подходящих под мою задачу, а именно, что должно быть в готовом решении:

• хэндлер get-запроса, который возвращает captcha_id и закодированное в base64 изображение этой самой капчи;

• хэндлер post-запроса, который вальсирует введенные пользователем данные с картинки. В идеале, чтобы в хендлере был вызов некого метода, который возвращает True/False в зависимости от результатов валидации, введенных пользователем данных. Это было бы очень удобно для расширения логики.

Казалось бы, что там особенного, наверняка есть решения. Начал искать. Попались на глаза:

• Django REST framework reCAPTCHA (не подходит из-за использования стороннего сервиса)

• Django YaCaptcha (не подходит по аналогичной причине)

• Django rest captcha (не удалось попробовать ввиду того, что библиотека не обновилась больше 2-х лет и не поддерживает Django 5.x)

• Django Simple Captcha (не подошло по текущей бизнес-логики + посмотрел код на GitHub и мне не понравилось, ну, что поделать — вкусы у всех разные)

Ввиду того, что ничего из того, что я нашел поиском в интернете, мне не подошло, было принято решение сделать все самому. Задача не выглядит как Rocket Science, да и кто из нас не любит строить свой велосипед, так что погнали…

Реализация

Описание логики работы

Упрощенно разобьем логику работы на 2 этапа:

• get-запрос на получение картинки капчи. На этом шаге мы генерируем 2 значения: captcha_id, captcha_value. Записываем эти значения в какое-нибудь хранилище (Postgres, Redis и т.д.) для дальнейшей проверки ввода пользователя. Так как у нас REST, то ответом будет json, который будет иметь 2 поля: captcha_id и image — картинка капчи, закодированная в base64.

• post-запрос для валидации данных капчи, введенных пользователем. Передаваемые от пользователя данные: captcha_id, captcha_value. Получаем из хранилища данных, куда до этого мы поместили капчу, данные по captcha_id . Сравниваем переданные пользователем captcha_value со значением, которое мы получили из хранилища данных. Если значения совпадают — пользователь ввел капчу правильно, то выдаем юзеру сгенерированный uuid-токен (тут я сразу буду описывать такую логику, так как в моей задаче нужно именно такое поведение). Если капча введена правильно, удаляем ее данные из хранилища данных (также по-хорошему надо ограничить время жизни капчи в хранилище по TTL).

Программируем

Для начала создадим новое Django-приложение, или, по-нашему, пакет: python manage.py startapp captcha
Сразу добавим его в INSTALLED_APPS в settings.py:

INSTALLED_APPS = [ ... "captcha", ]

Также в настройки добавим:

• переменную, отвечающую за длину капчи;

• переменную для префикса капчи в кэше;

• переменную, определяющую время жизни капчи в кэше;

• переменную, задающую размер изображения капчи.

CAPTCHA_LENGTH = env.int("CAPTCHA_LENGTH", default=4) CAPTCHA_CACHE_PREFIX = env.str("CAPTCHA_CACHE_PREFIX", default="captcha_") CAPTCHA_CACHE_TTL = env.int("CAPTCHA_CACHE_TTL", default=120) CAPTCHA_IMAGE_SIZE = env.tuple("CAPTCHA_IMAGE_SIZE", default=(90, 40))

Сделаем пакет с утилитами, в нем создадим модуль для генерации текста для капчи:

import random  from django.conf import settings   def generate_captcha_value(length: int = settings.CAPTCHA_LENGTH) -> str:     symbols = "abcdefghijklmnopqrstuvwxyz1234567890"     res = []      for _ in range(length):         res.append(random.choice(symbols))     result = "".join(res)      return result.upper()

Создадим модель Captcha в файле models.py

import uuid  from django.db import models from django.utils import timezone  from captcha.utils.generate import generate_captcha_value   class CaptchaModel(models.Model):     captcha_id = models.UUIDField(default=uuid.uuid4)     code = models.CharField(max_length=6, default=generate_captcha_value)     created_at = models.DateTimeField(default=timezone.now)      class Meta:         managed = False

Здесь я использую managed = False для того, чтобы таблица в БД не создавалась, так как данные капчи буду хранить в Redis. Далее я переопределю метод save модели для сохранения данных именно в Redis.

Добавим импорт:

from django.core.cache import cache

Сам метод save:

def save(self, *args, force_insert=False, force_update=False, using=None, update_fields=None):     cache.set(         f"{settings.CAPTCHA_CACHE_PREFIX}{self.captcha_id}",         self.code,         settings.CAPTCHA_CACHE_TTL,     )

Теперь займемся генерацией изображения с кодом капчи.
Эту логику вынесем в сервисный слой, для этого создадим пакет services в корне пакета captcha. Далее, в пакете services создадим модуль captcha_service.py и начнем писать сам сервис:

from django.conf import settings from PIL import Image, ImageDraw, ImageFont  from captcha.models import CaptchaModel   class CaptchaService:     def __init__(self):         self.captcha = CaptchaModel()         self.captcha.save()          self.font = ImageFont.truetype(settings.CAPTCHA_FONT_PATH, settings.CAPTCHA_FONT_SIZE)

Для отображения текста на картинке будем использовать шрифт Vera.ttf https://github.com/mps/fonts/blob/master/Vera.ttf. Скачаем этот шрифт и поместим в папку fonts внутри пакета captcha.
Добавим в settings.py нашего проекта путь к этому шрифту и размер шрифта:

CAPTCHA_FONT_PATH = os.path.join(BASE_DIR, "captcha/fonts/Vera.ttf") CAPTCHA_FONT_SIZE = env.int("CAPTCHA_FONT_SIZE", default=22)

Теперь давайте добавим метод для генерации изображения в CaptchaService:

def _generate_image(self) -> Image.Image:     image = Image.new("RGB", settings.CAPTCHA_IMAGE_SIZE, (128, 213, 215))     draw = ImageDraw.Draw(image)     text_width, text_height = self.font.getmask(self.captcha.code).size  # type: ignore     draw_points = (         (settings.CAPTCHA_IMAGE_SIZE[0] - text_width) // 2,         (settings.CAPTCHA_IMAGE_SIZE[1] - text_height) // 2,     )     draw.text(         draw_points,         self.captcha.code,  # type: ignore         font=self.font,         fill=(255, 255, 255),     )     image = image.filter(ImageFilter.GaussianBlur(1.5))      return image

Этот код генерирует объект Image.Image с заданными размерами, добавляет текст из капчи и добавляет размытие по Гауссу для осложнения автоматического распознавания текста, во всяком случае MacOS из коробки (стандартный просмотрщик умеет копировать текст с изображения) не смогла скопировать текст с капчи с такими настройками цвета фона и степени размытия.

Теперь надо сделать кодирование изображения в base64 для дальнейшей отправки клиенту (фронтэнду).

Добавим такой метод в CaptchaService:

def base_64_captcha_image(self) -> str:     image = self._generate_image()     buffered = BytesIO()     image.save(buffered, format="PNG")     return base64.b64encode(buffered.getvalue()).decode("utf-8")

Генерация капчи готова! Теперь наша задача сделать валидацию введенных пользователем данных. Для этих целей создадим еще один модуль в сервисном слое, назовем этот модуль validate_captcha.py. В этом модуле создадим сервис:

from django.conf import settings from django.core.cache import cache   class ValidateCaptchaService:     def __init__(self, code: str, captcha_id: str):         self.code = code         self.captcha_id = captcha_id              def validate(self) -> bool:         return (             cache.get(f"{settings.CAPTCHA_CACHE_PREFIX}{self.captcha_id}", "") == self.code.upper()         )

На этом основная работа закончена. Теперь создадим APIView для этих действий.
Но прежде сделаем сериализатор, который будет моделью ответа на запрос капчи. Создадим пакет serializers в корне пакета captcha. Там создадим модуль captcha_serializers.py.
Добавим код сериализатора:

from rest_framework import serializers   class CaptchaSerializer(serializers.Serializer):     captcha_id = serializers.CharField()     image = serializers.CharField()     created_at = serializers.DateTimeField()

В модуле views.py пакета captcha напишем следующий код:

from drf_spectacular.utils import extend_schema from rest_framework import status from rest_framework.response import Response from rest_framework.views import APIView  from captcha.serializers.captcha_serializers import CaptchaSerializer from captcha.services.captcha_service import CaptchaService from main.serializers.common_serializers import BadRequestSerializer   class CaptchAPIView(APIView):     @extend_schema(         description=("Запрос на получение Captcha"),         responses={             status.HTTP_200_OK: CaptchaSerializer,             status.HTTP_400_BAD_REQUEST: BadRequestSerializer,         },         tags=["captcha"],     )     def get(self, request) -> Response:         service = CaptchaService()         serializer = CaptchaSerializer(             data={                 "captcha_id": service.captcha.captcha_id,                 "created_at": service.captcha.created_at,                 "image": service.base_64_captcha_image(),             }         )          if serializer.is_valid():             return Response(serializer.data, status=status.HTTP_200_OK)         return Response(             BadRequestSerializer({"detail": serializer.errors}).data,             status=status.HTTP_400_BAD_REQUEST,         )

Здесь extend_schema — декоратор, который выводит описание метода в Swagger. Есть несколько известных решений swagger для DRF, но я в последнее время использую drf_spectacular . Кому-то может показаться слишком избыточно описывать методы при помощи декораторов, но я не вижу в этом ничего криминального. Конечно, в FastAPI все из коробки работает очень элегантно, но я уже смирился, что в DRF пока такого и близко нет и приходится использовать специальные для этого библиотеки. Кстати про Swagger и DRF, я вот такие еще использовал:

• drf-yasg https://drf-yasg.readthedocs.io/en/stable/readme.html

• django-rest-swagger https://django-rest-swagger.readthedocs.io/en/latest/ — сейчас уже неактуален, так как проект не обновлялся с 2021 года

Вот код BadRequestSerializer, который возвращается в случае ошибок:

from rest_framework import serializers   class BadRequestSerializer(serializers.Serializer):     detail = serializers.CharField()

Вообще, считается хорошей практикой создавать свои кастомные исключения Exceptions и свои стандартные наборы классов для работы с ошибками.

Ладно, продолжим. Создадим модуль urls.py в корне пакета captcha вот с таким содержимым:

from django.urls import path from captcha.views import CaptchAPIView urlpatterns = [    path("captcha/", CaptchAPIView.as_view(), name="captcha"), ]

В модуле urls.py в основном пакете проекта добавим этот код:

from django.urls import include urlpatterns = [ ... path("captcha/", include("captcha.urls")), ]

Итак, осталось сделать только валидацию данных капчи, введенных пользователем. Для этого нам потребуется сериализатор входных данных и сериализатор успешного ответа для хэндлера post-запроса.

Добавим в модуль captcha_serializers.py следующее:

class CaptchUserInputSerializer(serializers.Serializer):     code = serializers.CharField()     captcha_id = serializers.CharField()   class CaptchResponseSerializer(serializers.Serializer):     session_token = serializers.CharField()

Осталось совсем немного — добавить хэндлер post-запроса в класс CaptchAPIView модуля views.py пакета captcha:

@extend_schema(     description=("Валидация капчи. Если капча валидна, то возвращается session_token"),     request=CaptchUserInputSerializer,     responses={         status.HTTP_200_OK: CaptchResponseSerializer,         status.HTTP_400_BAD_REQUEST: BadRequestSerializer,     },     tags=["captcha"], ) def post(self, request) -> Response:     service = ValidateCaptchaService(request.data["code"], request.data["captcha_id"])      if service.validate() is True:         serializer = CaptchResponseSerializer(data={"session_token": str(uuid.uuid4())})         if serializer.is_valid():             return Response(serializer.data, status=status.HTTP_200_OK)         return Response(             BadRequestSerializer({"detail": serializer.errors}).data,             status=status.HTTP_400_BAD_REQUEST,         )     return Response(         BadRequestSerializer({"detail": "Invalid captcha"}).data,         status=status.HTTP_400_BAD_REQUEST,     )

В последнем листинге не стал добавлять импорты, так как, мне кажется, тут все очевидно.

На этом все, вот такой простенький велосипед мы сегодня нагородили, будем продвигать велосипедостроение 😉