django-defender — Una aplicación reutilizable de Django simple y muy rápida que bloquea los intentos de inicio de sesión por fuerza bruta. | Kitploit

DEFENDER_LOGIN_FAILURE_LIMIT\ : Int: El número de intentos de inicio de sesión permitidos antes de que se cree un registro para los inicios de sesión fallidos. [Predeterminado: 3\ ]
DEFENDER_LOGIN_FAILURE_LIMIT_USERNAME\ : Int: El número de intentos de inicio de sesión permitidos en un nombre de usuario antes de que se cree un registro para los inicios de sesión fallidos. [Predeterminado: DEFENDER_LOGIN_FAILURE_LIMIT\ ]
DEFENDER_LOGIN_FAILURE_LIMIT_IP\ : Int: El número de intentos de inicio de sesión permitidos desde una IP antes de que se cree un registro para los inicios de sesión fallidos. [Predeterminado: DEFENDER_LOGIN_FAILURE_LIMIT\ ]
DEFENDER_BEHIND_REVERSE_PROXY\ : Booleano: ¿Está defender detrás de un proxy inverso? [Predeterminado: False\ ]
DEFENDER_REVERSE_PROXY_HEADER\ : Cadena: el nombre de la cabecera http con su dirección IP de proxy inverso [Predeterminado: HTTP_X_FORWARDED_FOR\ ]
DEFENDER_LOCK_OUT_BY_IP_AND_USERNAME\ : Booleano: Bloquea a un usuario basado en una combinación de IP y Nombre de usuario. Esto evita que un usuario niegue el acceso a la aplicación a todos los demás usuarios que acceden a la aplicación desde detrás de la misma dirección IP. [Predeterminado: False\ ]
DEFENDER_DISABLE_IP_LOCKOUT\ : Booleano: Si es True, no bloqueará la dirección IP del usuario, solo bloqueará el nombre de usuario. [Predeterminado: False]
DEFENDER_DISABLE_USERNAME_LOCKOUT\ : Booleano: Si es True, no bloqueará nombres de usuario, solo bloqueará direcciones IP. [Predeterminado: False]
DEFENDER_COOLOFF_TIME\ : Int: Si se establece, define un período de inactividad después del cual los intentos de inicio de sesión fallidos antiguos y los bloqueos de nombre de usuario/IP serán olvidados. Un entero, se interpretará como un número de segundos. Si es 0, ni los intentos de inicio de sesión fallidos ni los bloqueos de nombre de usuario/IP expirarán. [Predeterminado: 300\ ]
DEFENDER_ATTEMPT_COOLOFF_TIME\ : Int: Si se establece, anula el período de inactividad después del cual los intentos de inicio de sesión fallidos antiguos serán olvidados establecido por DEFENDER_COOLOFF_TIME. Un entero, se interpretará como un número de segundos. Si es 0, los intentos de inicio de sesión fallidos no expirarán. [Predeterminado: DEFENDER_COOLOFF_TIME\ ]
DEFENDER_LOCKOUT_COOLOFF_TIME\ : Int o Lista: Si se establece, anula el período de inactividad después del cual los bloqueos de nombre de usuario/IP serán olvidados establecido por DEFENDER_COOLOFF_TIME. Un entero, se interpretará como un número de segundos. Una lista de enteros, se interpretará como un número de segundos para usuarios con el índice del entero siendo el número de bloqueos previos (hasta un máximo) ocurridos en las últimas DEFENDER_ACCESS_ATTEMPT_EXPIRATION horas. Si la propiedad se establece en 0 o [], el bloqueo de nombre de usuario/IP no expirará. [Predeterminado: DEFENDER_COOLOFF_TIME\ ]
DEFENDER_LOCKOUT_TEMPLATE\ : Cadena: [Predeterminado: None\ ] Si se establece, especifica una plantilla para renderizar cuando un usuario está bloqueado. La plantilla recibe las siguientes variables de contexto:
- cooloff_time_seconds\ : El tiempo de espera en segundos
- cooloff_time_minutes\ : El tiempo de espera en minutos
- failure_limit\ : El número de fallos antes de ser bloqueado.
DEFENDER_USERNAME_FORM_FIELD\ : Cadena: el nombre del campo del formulario que contiene sus nombres de usuario. [Predeterminado: username\ ]
DEFENDER_CACHE_PREFIX\ : Cadena: El prefijo de caché para sus claves de defender. [Predeterminado: defender\ ]
DEFENDER_LOCKOUT_URL\ : Cadena: La URL a la que desea redirigir si alguien está bloqueado.
DEFENDER_REDIS_URL\ : Cadena: la URL de redis para defender. [Predeterminado: redis://localhost:6379/0\ ] (Ejemplo con contraseña: redis://:mypassword@localhost:6379/0\ )
DEFENDER_REDIS_PASSWORD_QUOTE\ : Booleano: si hay caracteres especiales en la contraseña de redis (como '@'), podemos citar la contraseña urllib.parse.quote("password!@#"), y establecerlo en True. [Predeterminado: False\ ]
DEFENDER_REDIS_NAME\ : Cadena: el nombre de la caché de CACHES en su configuración de Django (p. ej. "default"). Si se establece, DEFENDER_REDIS_URL será ignorado. [Predeterminado: None\ ]
DEFENDER_STORE_ACCESS_ATTEMPTS\ : Booleano: Si desea almacenar el intento de inicio de sesión en la base de datos, establezca en True. Si es False, no se guarda. [Predeterminado: True\ ]
DEFENDER_USE_CELERY\ : Booleano: Si desea usar Celery para almacenar el intento de inicio de sesión en la base de datos, establezca en True. Si es False, se guarda en línea. [Predeterminado: False\ ]
DEFENDER_ACCESS_ATTEMPT_EXPIRATION\ : Int: Tiempo en horas durante el cual mantener los registros de intentos de acceso en la base de datos antes de que el comando de gestión los limpie. [Predeterminado: 24\ ]
DEFENDER_GET_USERNAME_FROM_REQUEST_PATH\ : Cadena: La ruta de importación de la función que accede al nombre de usuario desde la solicitud. Si desea usar una función personalizada para acceder y procesar el nombre de usuario desde la solicitud, puede especificarla aquí. [Predeterminado: defender.utils.username_from_request\ ]

   def authenticate(self, request):
       auth = get_authorization_header(request).split()

       if not auth or auth[0].lower() != b'basic':
           return None

       if len(auth) == 1:
           msg = _('Invalid basic header. No credentials provided.')
           raise exceptions.AuthenticationFailed(msg)
       elif len(auth) > 2:
           msg = _('Invalid basic header. Credentials string should not contain spaces.')
           raise exceptions.AuthenticationFailed(msg)

       if utils.is_already_locked(request, get_username=self.get_username_from_request):
           detail = "You have attempted to login {failure_limit} times, with no success." \
                    "Your account is locked for {cooloff_time_seconds} seconds" \
                    "".format(
                       failure_limit=config.FAILURE_LIMIT,
                       cooloff_time_seconds=config.LOCKOUT_COOLOFF_TIME[
                          defender_utils.get_lockout_cooloff_time(username=self.get_username_from_request(request))
                       ]
                    )
           raise exceptions.AuthenticationFailed(_(detail))

       try:
           auth_parts = base64.b64decode(auth[1]).decode(HTTP_HEADER_ENCODING).partition(':')
       except (TypeError, UnicodeDecodeError, binascii.Error):
           msg = _('Invalid basic header. Credentials not correctly base64 encoded.')
           raise exceptions.AuthenticationFailed(msg)

       userid, password = auth_parts[0], auth_parts[2]
       login_unsuccessful = False
       login_exception = None
       try:
           response = self.authenticate_credentials(userid, password)
       except exceptions.AuthenticationFailed as e:
           login_unsuccessful = True
           login_exception = e

       utils.add_login_attempt_to_db(request,
                                     login_valid=not login_unsuccessful,
                                     get_username=self.get_username_from_request)
       # add the failed attempt to Redis in case of a failed login or resets the attempt count in case of success
       utils.check_request(request,
                           login_unsuccessful=login_unsuccessful,
                           get_username=self.get_username_from_request)
       if login_unsuccessful:
           raise login_exception

       return response

  username = serializers.CharField(required=False, allow_blank=True)
  email = serializers.EmailField(required=False, allow_blank=True)
  password = serializers.CharField(style={'input_type': 'password'})

  def authenticate(self, **kwargs):
    request = self.context['request']

    if hasattr(settings, 'ACCOUNT_AUTHENTICATION_METHOD'):
        login_field = settings.ACCOUNT_AUTHENTICATION_METHOD
    else:
        login_field = 'username'
    userid = self.username_from_request(request, login_field)

    if defender_utils.is_already_locked(request, username=userid):
        detail = "You have attempted to login {failure_limit} times with no success. "
                 .format(
                     failure_limit=config.FAILURE_LIMIT,
                     cooloff_time_seconds=config.LOCKOUT_COOLOFF_TIME[defender_utils.get_lockout_cooloff_time(username=userid)]
                 )
        raise exceptions.AuthenticationFailed(_(detail))

    login_unsuccessful = False
    login_exception = None
    try:
        response = authenticate(request, **kwargs)
        if response == None:
            login_unsuccessful = True
            msg = _('Unable to log in with provided credentials.')
            # raise exceptions.ValidationError(msg)
            login_exception = exceptions.ValidationError(msg)
    except exceptions.AuthenticationFailed as e:
        login_unsuccessful = True
        login_exception = e

    defender_utils.add_login_attempt_to_db(request,
                                           login_valid=not login_unsuccessful,
                                           username=userid)

    user_not_blocked = defender_utils.check_request(request,
                                                    login_unsuccessful=login_unsuccessful,
                                                    username=userid)
    if user_not_blocked and not login_unsuccessful:
        return response

    raise login_exception

  def _validate_email(self, email, password):
    user = None

    if email and password:
        user = self.authenticate(email=email, password=password)
    else:
        msg = _('Must include "email" and "password".')
        raise exceptions.ValidationError(msg)

    return user

  def _validate_username(self, username, password):
    user = None

    if username and password:
        user = self.authenticate(username=username, password=password)
    else:
        msg = _('Must include "username" and "password".')
        raise exceptions.ValidationError(msg)

    return user

  def _validate_username_email(self, username, email, password):
    user = None

    if email and password:
        user = self.authenticate(email=email, password=password)
    elif username and password:
        user = self.authenticate(username=username, password=password)
    else:
        msg = _('Must include either "username" or "email" and "password".')
        raise exceptions.ValidationError(msg)

    return user

  def validate(self, attrs):
    username = attrs.get('username')
    email = attrs.get('email')
    password = attrs.get('password')

    user = None

    if 'allauth' in settings.INSTALLED_APPS:
        from allauth.account import app_settings

        # Authentication through email
        if app_settings.AUTHENTICATION_METHOD == app_settings.AuthenticationMethod.EMAIL:
            user = self._validate_email(email, password)

        # Authentication through username
        elif app_settings.AUTHENTICATION_METHOD == app_settings.AuthenticationMethod.USERNAME:
            user = self._validate_username(username, password)

        # Authentication through either username or email
        else:
            user = self._validate_username_email(username, email, password)

    else:
        # Authentication without using allauth
        if email:
            try:
                username = UserModel.objects.get(
                    email__iexact=email).username()
            except UserModel.DoesNotExist:
                pass

        if username:
            user = self._validate_username_email(username, '', password)

    # Did we get back an active user?
    if user:
        if not user.is_active:
            msg = _('User account is disabled.')
            raise exceptions.ValidationError(msg)
    else:
        msg = _('Unable to log in with provided credentials.')
        raise exceptions.ValidationError(msg)

    # If required, is the email verified?
    if 'rest_auth.registration' in settings.INSTALLED_APPS:
        from allauth.account import app_settings
        if app_settings.EMAIL_VERIFICATION == app_settings.EmailVerificationMethod.MANDATORY:
            email_address = user.emailaddress_set.get(email=user.email)
            if not email_address.verified:
                raise serializers.ValidationError(
                    _('E-mail is not verified.'))

    attrs['user'] = user
    return attrs

  def username_from_request(self, request, login_field):
    user_data = request._data
    return user_data[login_field]

from defender import utils as def_utils
from django.contrib.auth import views as auth_views

class UserSignIn(auth_views.LoginView):
    def form_valid(self, form):
        """Forzar la limpieza de todos los estados de Defender almacenados en caché para la dirección de correo electrónico del usuario autenticado."""
        super_valid = super().form_valid(form)
        def_utils.check_request(self.request, False, username=form.get_user().email)
        return super_valid

class PasswordResetBruteForceProtectedView(auth_views.PasswordResetView):
    def get(self, request, *args, **kwargs):
        """Confirmar que el usuario no está ya bloqueado por IP antes de mostrar la vista de restablecimiento de contraseña."""
        if def_utils.is_already_locked(request):
            return def_utils.lockout_response(request)
        return super().get(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        """
        Confirmar que el usuario no está ya bloqueado por IP antes de permitir el envío del formulario.

        También, forzar el registro de este envío de formulario como una única entrada en la caché de Defender, contra la dirección de correo electrónico enviada.
        """
        if def_utils.is_already_locked(request):
            return def_utils.lockout_response(request)
        def_utils.check_request(
            request, login_unsuccessful=True, username=request.POST.get("email")
        )
        return super().post(request, *args, **kwargs)


class PasswordResetConfirmBruceForceProtectedView(auth_views.PasswordResetConfirmView):
    def get(self, request, *args, **kwargs):
        """Confirmar que el usuario no está ya bloqueado por IP antes de mostrar la vista de confirmación de contraseña."""
        if def_utils.is_already_locked(request):
            return def_utils.lockout_response(request)
        return super().get(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        """Confirmar que el usuario no está ya bloqueado por IP antes de permitir el envío del formulario para la confirmación de cambio de contraseña."""
        if def_utils.is_already_locked(request):
            return def_utils.lockout_response(request)
        return super().post(request, *args, **kwargs)

    def form_valid(self, form):
        """Forzar la limpieza de todos los estados de Defender almacenados en caché para la dirección de correo electrónico del usuario después de cambiar exitosamente su contraseña."""
        super_valid = super().form_valid(form)
        def_utils.check_request(
            self.request, login_unsuccessful=False, username=self.user.email
        )
        return super_valid

django-defender

Más Populares

Sitios que usan django-defender

Documentación

Características

Requisitos

Instalación

ejecutar a las 12:24 AM cada mañana.

Objetivos a largo plazo

Por qué no django-axes

Cómo funciona django-defender

Backend de caché

Personalizando django-defender

Adaptación a otros métodos de autenticación

Adaptación a otros métodos de autenticación :- django-rest-auth en djangorestframework

Get the UserModel

Adaptación para formularios de restablecimiento de contraseña

Señales de Django

Ejecutar pruebas

Publicación