Разработка модульной системы аутентификации с использованием модели метода производства в Джанго

Реализация шаблона в Джанго

Мы начнем с создания минимального, но готового к производству модуля аутентификации. Структура проекта может выглядеть следующим образом:

myproject/
 authfactory/
 __init__.py
 base_auth.py
 backends.py
 factory.py
 views.py
 templates/
 settings.py

Абстрактный класс аутентификации

Создайте абстрактный базовый класс, который определяет интерфейс, который должен реализовать каждый конкретный бэкэнд. Этот интерфейс будет содержать, по крайней мере, метод , но вы также можете добавить дополнительные крючки, такие как или методы для обработки после аутентификации.

# authfactory/base_auth.py
from abc import ABC, abstractmethod

class BaseAuthMethod(ABC):
 """Common interface for all authentication strategies."""

 @abstractmethod
 def authenticate(self, request):
 """
 Authenticate the user from the given request.
 Must return a User instance on success, or None on failure.
 """
 pass

 def get_user(self, user_id):
 """
 Optional method to retrieve a user object by ID.
 Can be used by backends that support session restoration.
 """
 return None

Использование гарантирует, что любой подкласс должен реализовать или Python поднимет во время инстанциации.

Конкретная аутентификация Backends

Теперь реализуем конкретные классы для наиболее распространенных методов аутентификации.

• Аутентификация имени пользователя / пароля (с использованием встроенного Django )
• Аутентификация OAuth2 (абстрактный пример)
• JSON Web Token (JWT) аутентификация для клиентов API
• Социальный логин через django-allauth

Имя пользователя / Password Backend

Этот бэкэнд делегирует собственную систему аутентификации Django, которая проверена в бою и включает в себя хеширование паролей, дросселирование и другие функции безопасности.

# authfactory/backends.py
from django.contrib.auth import authenticate
from .base_auth import BaseAuthMethod

class UsernamePasswordAuth(BaseAuthMethod):
 def authenticate(self, request):
 username = request.POST.get('username')
 password = request.POST.get('password')
 return authenticate(request, username=username, password=password)

 def get_user(self, user_id):
 from django.contrib.auth import get_user_model
 User = get_user_model()
 try:
 return User.objects.get(pk=user_id)
 except User.DoesNotExist:
 return None

OAuth2 Backend

Потоки OAuth2 более сложны. Этот пример показывает, как вы можете проверить токен доступа, полученный от стороннего поставщика.

# authfactory/backends.py (continued)
import requests
from django.contrib.auth import get_user_model
from .base_auth import BaseAuthMethod

class OAuth2Auth(BaseAuthMethod):
 def __init__(self, provider_token_url, userinfo_url, client_id):
 self.provider_token_url = provider_token_url
 self.userinfo_url = userinfo_url
 self.client_id = client_id

 def authenticate(self, request):
 access_token = request.POST.get('access_token') or \
 request.META.get('HTTP_AUTHORIZATION', '').replace('Bearer ', '')
 if not access_token:
 return None
 # Verify token with the provider's introspection endpoint (simplified)
 response = requests.get(
 self.userinfo_url,
 headers={'Authorization': f'Bearer {access_token}'}
 )
 if response.status_code != 200:
 return None
 user_info = response.json()
 email = user_info.get('email')
 if not email:
 return None
 User = get_user_model()
 user, _ = User.objects.get_or_create(
 email=email,
 defaults={'username': email.split('@')[0]}
 )
 return user

 def get_user(self, user_id):
 User = get_user_model()
 try:
 return User.objects.get(pk=user_id)
 except User.DoesNotExist:
 return None

Обратите внимание, что производственные бэкэнды OAuth2 также должны проверять подпись токена, проверять истечение срока действия и, возможно, проверять утверждение . В надежной реализации будет использоваться библиотека, такая как или .

JWT Backend (для REST API)

При создании API с Django REST Framework (DRF) часто требуется аутентифицировать пользователей через JSON Web Tokens. Следующий бэкэнд проверяет JWT и извлекает пользователя из полезной нагрузки.

# authfactory/backends.py (continued)
import jwt
from django.conf import settings
from django.contrib.auth import get_user_model
from .base_auth import BaseAuthMethod

class JWTAuth(BaseAuthMethod):
 def __init__(self, secret_key=None, algorithm='HS256'):
 self.secret_key = secret_key or settings.SECRET_KEY
 self.algorithm = algorithm

 def authenticate(self, request):
 token = request.META.get('HTTP_AUTHORIZATION', '').replace('Bearer ', '')
 if not token:
 return None
 try:
 payload = jwt.decode(
 token,
 self.secret_key,
 algorithms=[self.algorithm]
 )
 except (jwt.ExpiredSignatureError, jwt.InvalidTokenError):
 return None
 user_id = payload.get('user_id')
 if not user_id:
 return None
 User = get_user_model()
 try:
 return User.objects.get(pk=user_id)
 except User.DoesNotExist:
 return None

 def get_user(self, user_id):
 User = get_user_model()
 try:
 return User.objects.get(pk=user_id)
 except User.DoesNotExist:
 return None

Социальный вход через django-allauth

Если вы используете для социальной аутентификации, вы можете обернуть его внутри фабричного бэкэнда. Этот пример предполагает, что социальный поток входа обрабатывается взглядами Аллаута; заводской бэкэнд будет называться после обратного вызова OAuth для завершения входа.

# authfactory/backends.py (continued)
from allauth.socialaccount.models import SocialLogin, SocialAccount
from django.contrib.auth import get_user_model
from .base_auth import BaseAuthMethod

class SocialAuthBackend(BaseAuthMethod):
 def __init__(self, provider):
 self.provider = provider

 def authenticate(self, request):
 # This is called after allauth's social login process.
 # The user object is typically stored in the request by allauth.
 if hasattr(request, 'user') and request.user.is_authenticated:
 return request.user
 # Alternatively, you could inspect the session for a social token.
 return None

 def get_user(self, user_id):
 User = get_user_model()
 try:
 return User.objects.get(pk=user_id)
 except User.DoesNotExist:
 return None

Этот бэкэнд намеренно прост; полная интеграция будет обрабатывать машину состояния социального входа, управляемую Allauth. Ключевой момент заключается в том, что каждый бэкэнд соответствует одному и тому же интерфейсу .

Фабричный класс

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

# authfactory/factory.py
from django.conf import settings
from .backends import (
 UsernamePasswordAuth,
 OAuth2Auth,
 JWTAuth,
 SocialAuthBackend,
)

class AuthMethodFactory:
 """Factory that returns the appropriate authentication backend."""

 _backends = {
 'username_password': UsernamePasswordAuth,
 'oauth2': lambda: OAuth2Auth(
 provider_token_url=settings.OAUTH2_TOKEN_URL,
 userinfo_url=settings.OAUTH2_USERINFO_URL,
 client_id=settings.OAUTH2_CLIENT_ID,
 ),
 'jwt': lambda: JWTAuth(
 secret_key=settings.JWT_SECRET_KEY,
 algorithm=settings.JWT_ALGORITHM,
 ),
 'social': lambda: SocialAuthBackend(provider='google'),
 }

 @classmethod
 def get_backend(cls, method_type, **kwargs):
 """
 Return an instance of the authentication backend
 identified by `method_type`.
 """
 if method_type not in cls._backends:
 raise ValueError(f"Unknown authentication method: {method_type}")
 backend_creator = cls._backends[method_type]
 if callable(backend_creator):
 return backend_creator()
 return backend_creator()

 @classmethod
 def get_backend_names(cls):
 """Return a list of all registered backend names."""
 return list(cls._backends.keys())

Эта реализация использует словарь лямбда для ленивого создания бэкэндов, требующих аргументов конструктора.Метод также может принимать дополнительные аргументы ключевых слов, если вам нужно переопределить параметры по умолчанию для конкретного запроса (например, другой поставщик).

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

Использование фабрики в Views и Middleware

Теперь интегрируйте завод в свои представления Django. Клиент (браузер или потребитель API) должен сообщить серверу, какой метод аутентификации он намерен использовать. Это может быть сделано с помощью параметра запроса, поля POST или пользовательского заголовка HTTP.

Традиционный вид входа

# authfactory/views.py
from django.contrib.auth import login
from django.http import HttpResponse, Http404
from django.views.decorators.csrf import csrf_exempt
import json
from .factory import AuthMethodFactory

@csrf_exempt
def login_view(request):
 """
 Login endpoint that supports multiple authentication methods.
 Expects a JSON body with 'auth_type' and method-specific credentials.
 """
 if request.method != 'POST':
 return HttpResponse(status=405, content='Method not allowed')

 try:
 data = json.loads(request.body)
 except json.JSONDecodeError:
 return HttpResponse(status=400, content='Invalid JSON')

 auth_type = data.get('auth_type', 'username_password')
 try:
 backend = AuthMethodFactory.get_backend(auth_type)
 except ValueError as e:
 return HttpResponse(status=400, content=str(e))

 user = backend.authenticate(request)
 if user is not None:
 login(request, user, backend='django.contrib.auth.backends.ModelBackend')
 return HttpResponse('Login successful')
 else:
 return HttpResponse(status=401, content='Invalid credentials')

Примечание: Функция требует параметра бэкэнд-струны. В реальном приложении вы либо храните бэкэнд-путь в сессии, либо используете бэкэнд-класс завода, чтобы автоматически вывести путь. Для простоты мы здесь жестко закодировали ; в производстве вы можете сопоставить каждый заводской бэкэнд с бэкэнд-струной аутентификации Django.

API-интерфейс с Django REST Framework

Если вы разоблачаете API, вы можете адаптировать заводской шаблон для использования с классами аутентификации DRF. Вместо создания отдельного представления напишите пользовательский класс аутентификации, который делегирует заводу.

# authfactory/rest_auth.py
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from .factory import AuthMethodFactory

class FactoryBackendAuth(BaseAuthentication):
 """
 DRF authentication class that uses the AuthMethodFactory
 to validate tokens. The 'auth_type' is derived from a custom
 header 'X-Auth-Type'.
 """

 def authenticate(self, request):
 auth_type = request.META.get('HTTP_X_AUTH_TYPE', 'jwt')
 try:
 backend = AuthMethodFactory.get_backend(auth_type)
 except ValueError:
 raise AuthenticationFailed('Unsupported authentication type')

 user = backend.authenticate(request)
 if user is None:
 raise AuthenticationFailed('Invalid token')
 return (user, None)

 def authenticate_header(self, request):
 return 'Bearer' # Generic challenge for any method

Затем добавьте этот класс аутентификации в настройки или вид DRF:

# settings.py
REST_FRAMEWORK = {
 'DEFAULT_AUTHENTICATION_CLASSES': [
 'authfactory.rest_auth.FactoryBackendAuth',
 # other classes can be kept as fallback
 ],
}

Промежуточное ПО для автоматического выбора Backend

Иногда вам нужно автоматически выбрать бэкэнд на основе характеристик запроса (например, пользовательский агент, IP, домен). Вы можете написать промежуточное ПО, которое обернет запрос и введет соответствующий бэкэнд в .

# authfactory/middleware.py
from .factory import AuthMethodFactory

class AutoAuthBackendMiddleware:
 """
 Middleware that selects an authentication backend based on
 the request path or host.
 """
 def __init__(self, get_response):
 self.get_response = get_response

 def __call__(self, request):
 # Decide on auth type - example: use 'oauth2' for /api/v2/auth/*
 path = request.path_info
 if path.startswith('/api/v2/auth/'):
 request.auth_type = 'oauth2'
 elif path.startswith('/api/v1/auth/'):
 request.auth_type = 'jwt'
 else:
 request.auth_type = 'username_password'
 return self.get_response(request)

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

Передовые соображения

Логика и обработка ошибок

Системы аутентификации производства нуждаются в надежной регистрации. Добавьте структурированную запись в каждый бэкэнд и завод, чтобы захватить попытки аутентификации, сбои и потенциальные события безопасности.

import logging
logger = logging.getLogger(__name__)

class JWTAuth(BaseAuthMethod):
 def authenticate(self, request):
 # ... validation ...
 if not token:
 logger.warning('JWT auth attempted with no token')
 return None
 try:
 payload = jwt.decode(token, self.secret_key, algorithms=[self.algorithm])
 except jwt.ExpiredSignatureError:
 logger.info('Expired JWT token')
 return None
 except jwt.InvalidTokenError:
 logger.warning('Invalid JWT token')
 return None
 # ... user retrieval ...
 if user is None:
 logger.error(f'JWT valid but user {payload.get("user_id")} not found')
 return user

Тестирование фабрики и бэкэндов

Каждый бэкэнд должен быть протестирован изолированно. Используйте тестовый клиент Django или макетные запросы. Для завода проверьте, что он возвращает правильный тип для каждого зарегистрированного метода и повышает для неизвестных.

# tests/test_auth.py
from django.test import TestCase
from unittest.mock import Mock
from authfactory.factory import AuthMethodFactory
from authfactory.backends import UsernamePasswordAuth, OAuth2Auth

class FactoryTest(TestCase):
 def test_get_username_password_backend(self):
 backend = AuthMethodFactory.get_backend('username_password')
 self.assertIsInstance(backend, UsernamePasswordAuth)

 def test_get_oauth2_backend(self):
 backend = AuthMethodFactory.get_backend('oauth2')
 self.assertIsInstance(backend, OAuth2Auth)

 def test_unknown_method_raises_error(self):
 with self.assertRaises(ValueError):
 AuthMethodFactory.get_backend('unknown')

class UsernamePasswordAuthTest(TestCase):
 def test_authenticate_with_valid_credentials(self):
 # Create a test user
 from django.contrib.auth import get_user_model
 User = get_user_model()
 user = User.objects.create_user(username='test', password='secret')
 # ... mock request ...
 request = Mock()
 request.POST = {'username': 'test', 'password': 'secret'}
 backend = UsernamePasswordAuth()
 result = backend.authenticate(request)
 self.assertEqual(result, user)

Расширение системы

Чтобы добавить новый метод аутентификации (например, SAML, магическая ссылка, WebAuthn), вам нужно только:

1. Создайте новый класс, который наследует от и реализует .
2. Зарегистрируйте его в словаре в .
3. Дополнительно добавьте запись конфигурации в настройках Django.

Этот минимальный размер делает систему легкой в обслуживании и тестировании. Вы также можете упаковать каждый бэкэнд в отдельное многоразовое приложение.

Преимущества использования шаблона метода фабрики для аутентификации

• Модульность: Каждый метод аутентификации инкапсулируется в свой собственный класс, что облегчает навигацию и рассуждение о кодовой базе.
• Масштабируемость: Добавление новой стратегии аутентификации не требует изменений существующих просмотров, URL-адресов или бизнес-логики.
• Открытый/Закрытый принцип: Основная инфраструктура аутентификации закрыта для модификации, но открыта для расширения через новые бэкэнд-классы.
• Проверяемость: Бэкенды могут быть протестированы самостоятельно. Пересмешка фабрики позволяет тестировать просмотры без реальных зависимостей аутентификации.
• Конфигурируемость: Завод может управляться настройками, записями баз данных или параметрами времени выполнения, позволяя различным средам развертывания использовать различные методы аутентификации.
• Разделение озабоченностей: Логика аутентификации удаляется из представлений, делая представления более легкими и более сфокусированными на обработке запросов.