Autenticación DRF de Python: Implementación de Token vs. JWT para APIs Robustas

Asegurar sus APIs es primordial. Al crear APIs con Python y Django REST Framework (DRF), tiene varias opciones de autenticación disponibles. Este artículo profundiza en dos métodos populares: la autenticación por token y la autenticación JWT (JSON Web Token), comparando sus fortalezas y debilidades y proporcionando ejemplos prácticos de implementación.

Comprendiendo la Autenticación en las APIs

La autenticación es el proceso de verificar la identidad de un usuario o aplicación que accede a su API. Un sistema de autenticación bien implementado garantiza que solo las entidades autorizadas puedan acceder a los recursos protegidos. En el contexto de las APIs RESTful, la autenticación típicamente implica el envío de credenciales (por ejemplo, nombre de usuario y contraseña) con cada solicitud. El servidor luego verifica estas credenciales y, si son válidas, otorga acceso.

Autenticación por Token

La autenticación por token es un mecanismo simple y directo. Cuando un usuario inicia sesión con éxito, el servidor genera un token único y aleatorio y lo almacena en la base de datos, asociándolo con el usuario. El cliente luego envía este token en el encabezado 'Authorization' de las solicitudes posteriores. El servidor recupera el token de la base de datos, verifica su validez y otorga acceso en consecuencia.

Implementación con DRF

DRF proporciona soporte integrado para la autenticación por token. Aquí se explica cómo implementarlo:

1. Instale DRF y regístrelo en su proyecto Django:

Primero, asegúrese de tener instalado Django REST Framework:

            pip install djangorestframework
            

              
                Copy
              
            
          

Luego, agréguelo a su `INSTALLED_APPS` en `settings.py`:

            INSTALLED_APPS = [
    ...
    'rest_framework',
]
            

              
                Copy
              
            
          

2. Agregue el esquema TokenAuthentication como una clase de autenticación predeterminada (opcional, pero recomendado):

En su archivo `settings.py`, agregue lo siguiente:

            REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
}
            

              
                Copy
              
            
          

Esto aplicará la autenticación por token globalmente en toda su API. `SessionAuthentication` se incluye para la interacción basada en el navegador, pero puede eliminarlo para una aplicación puramente basada en API.

3. Cree un token para cada usuario:

Puede crear tokens automáticamente para los usuarios al crearlos agregando un controlador de señal. Cree un archivo llamado `signals.py` en su aplicación (por ejemplo, `users/signals.py`):

            from django.conf import settings
from django.db.models.signals import post_save
from django.dispatch import receiver
from rest_framework.authtoken.models import Token

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_auth_token(sender, instance=None, created=False, **kwargs):
    if created:
        Token.objects.create(user=instance)
            

              
                Copy
              
            
          

Luego, importe este archivo `signals.py` en su archivo `users/apps.py` dentro del método `ready` de su clase de configuración de la aplicación. Ejemplo para `users/apps.py`:

            from django.apps import AppConfig

class UsersConfig(AppConfig):
    default_auto_field = 'django.db.BigAutoField'
    name = 'users'

    def ready(self):
        import users.signals
            

              
                Copy
              
            
          

Ahora puede administrar tokens usando la línea de comandos:

            python manage.py drf_create_token <username>
            

              
                Copy
              
            
          

4. Implemente sus vistas de API:

Aquí hay un ejemplo simple de una vista que requiere autenticación por token:

            from rest_framework import permissions
from rest_framework.response import Response
from rest_framework.views import APIView

class ExampleView(APIView):
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        content = {
            'message': '¡Hola, ' + request.user.username + '! Estás autenticado.',
        }
        return Response(content)
            

              
                Copy
              
            
          

En este ejemplo, `authentication_classes` especifica que se debe usar la autenticación por token y `permission_classes` especifica que solo los usuarios autenticados pueden acceder a la vista.

5. Incluya la vista de API de inicio de sesión:

También necesita un punto final para crear el token al iniciar sesión correctamente:

            from django.contrib.auth import authenticate
from rest_framework import status
from rest_framework.authtoken.models import Token
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny
from rest_framework.response import Response

@api_view(['POST'])
@permission_classes([AllowAny])
def login(request):
    username = request.data.get('username')
    password = request.data.get('password')
    user = authenticate(username=username, password=password)
    if user:
        token, _ = Token.objects.get_or_create(user=user)
        return Response({'token': token.key})
    else:
        return Response({'error': 'Credenciales inválidas'}, status=status.HTTP_401_UNAUTHORIZED)
            

              
                Copy
              
            
          

Ventajas de la autenticación por token

• Simplicidad: Fácil de implementar y entender.
• Sin estado: Cada solicitud de token contiene información que le permite ser independiente.

Desventajas de la autenticación por token

• Dependencia de la base de datos: Requiere una búsqueda en la base de datos para cada solicitud para validar el token. Esto puede afectar el rendimiento, especialmente a escala.
• Revocación de token: Revocar un token requiere eliminarlo de la base de datos, lo cual puede ser complejo.
• Escalabilidad: Puede que no sea la solución más escalable para APIs grandes y con mucho tráfico debido a la sobrecarga de la base de datos.

Autenticación JWT (JSON Web Token)

La autenticación JWT es un enfoque más moderno y sofisticado. Un JWT es un objeto JSON compacto y seguro para URL que contiene reclamaciones sobre el usuario. Estas reclamaciones se firman digitalmente utilizando una clave secreta o un par de claves pública/privada. Cuando un usuario inicia sesión, el servidor genera un JWT y lo envía al cliente. El cliente luego incluye este JWT en el encabezado 'Authorization' de las solicitudes posteriores. El servidor puede verificar la firma del JWT sin necesidad de acceder a una base de datos, lo que lo convierte en una solución más eficiente y escalable.

Implementación con DRF

DRF no proporciona soporte integrado para la autenticación JWT, pero varias bibliotecas excelentes facilitan la integración. Una de las más populares es `djangorestframework-simplejwt`.

1. Instale `djangorestframework-simplejwt`:

            pip install djangorestframework-simplejwt
            

              
                Copy
              
            
          

2. Configure la configuración de DRF:

En su archivo `settings.py`, agregue lo siguiente:

            REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_simplejwt.authentication.JWTAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ),
}

SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=5),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
    'ROTATE_REFRESH_TOKENS': False,
    'BLACKLIST_AFTER_ROTATION': True,

    'ALGORITHM': 'HS256',
    'SIGNING_KEY': settings.SECRET_KEY,
    'VERIFYING_KEY': None,
    'AUTH_HEADER_TYPES': ('Bearer',),
    'USER_ID_FIELD': 'id',
    'USER_ID_CLAIM': 'user_id',

    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),
    'TOKEN_TYPE_CLAIM': 'token_type',
}
            

              
                Copy
              
            
          

Explicación de la configuración:

• `ACCESS_TOKEN_LIFETIME`: Cuánto tiempo es válido el token de acceso (ejemplo, 5 minutos).
• `REFRESH_TOKEN_LIFETIME`: Cuánto tiempo es válido el token de actualización (ejemplo, 1 día). Los tokens de actualización se utilizan para obtener nuevos tokens de acceso sin requerir que el usuario vuelva a iniciar sesión.
• `ROTATE_REFRESH_TOKENS`: Si se rotan los tokens de actualización después de cada uso.
• `BLACKLIST_AFTER_ROTATION`: Si se ponen en la lista negra los tokens de actualización antiguos después de la rotación.
• `ALGORITHM`: El algoritmo utilizado para firmar el JWT (HS256 es una opción común).
• `SIGNING_KEY`: La clave secreta utilizada para firmar el JWT (típicamente su Django SECRET_KEY).
• `AUTH_HEADER_TYPES`: El tipo de encabezado de autorización (típicamente "Bearer").

3. Incluya las vistas de API de inicio de sesión y token de actualización:

`djangorestframework-simplejwt` proporciona vistas para obtener y actualizar tokens. Inclúyalos en su `urls.py`:

            from django.urls import path
from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
)

urlpatterns = [
    path('token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]
            

              
                Copy
              
            
          

`TokenObtainPairView` proporciona tokens de acceso y actualización después de una autenticación exitosa. `TokenRefreshView` proporciona un nuevo token de acceso cuando se proporciona un token de actualización válido.

4. Implemente sus vistas de API:

Aquí hay un ejemplo simple de una vista que requiere autenticación JWT:

            from rest_framework import permissions
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework_simplejwt.authentication import JWTAuthentication

class ExampleView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        content = {
            'message': '¡Hola, ' + request.user.username + '! Estás autenticado.',
        }
        return Response(content)
            

              
                Copy
              
            
          

Similar al ejemplo de autenticación por token, `authentication_classes` especifica que se debe usar la autenticación JWT y `permission_classes` restringe el acceso solo a los usuarios autenticados.

Ventajas de la autenticación JWT

• Escalabilidad: No se requiere una búsqueda en la base de datos para la validación del token, lo que lo hace más escalable.
• Sin estado: El JWT contiene toda la información necesaria para la autenticación.
• Estandarizado: JWT es un estándar ampliamente adoptado, compatible con muchas bibliotecas y plataformas.
• Apto para microservicios: Adecuado para arquitecturas de microservicios, ya que los servicios pueden verificar JWT de forma independiente.

Desventajas de la autenticación JWT

• Complejidad: Más complejo de implementar que la autenticación por token.
• Tamaño del token: Los JWT pueden ser más grandes que los tokens simples, lo que potencialmente aumenta el uso del ancho de banda.
• Revocación de token: Revocar un JWT es un desafío. Una vez emitido, es válido hasta su vencimiento. Las soluciones implican incluir en la lista negra los tokens revocados, lo que reintroduce la dependencia de la base de datos.

Estrategias de revocación de tokens

Tanto los métodos de autenticación por token como JWT requieren mecanismos para revocar el acceso. Aquí le mostramos cómo puede abordar la revocación de tokens:

Revocación de la autenticación por token

Con la autenticación por token, la revocación es sencilla: simplemente elimine el token de la base de datos:

            from rest_framework.authtoken.models import Token

try:
    token = Token.objects.get(user=request.user)
    token.delete()
except Token.DoesNotExist:
    pass
            

              
                Copy
              
            
          

Revocación de autenticación JWT

La revocación de JWT es más compleja porque el token en sí es autocontenido y no se basa en una búsqueda en la base de datos para la validación (inicialmente). Las estrategias comunes incluyen:

• Lista negra de tokens: Almacene los tokens revocados en una lista negra (por ejemplo, una tabla de base de datos o una caché de Redis). Antes de validar un JWT, verifique si está en la lista negra. `djangorestframework-simplejwt` proporciona soporte integrado para incluir en la lista negra los tokens de actualización.
• Tiempos de expiración cortos: Use tiempos de expiración de token de acceso cortos y confíe en los tokens de actualización para obtener nuevos tokens de acceso con frecuencia. Esto limita la ventana de oportunidad para que se utilice un token comprometido.
• Rotar tokens de actualización: Rotar los tokens de actualización después de cada uso. Esto invalidará los tokens antiguos cada vez y evitará el robo de tokens.

OAuth2 y OpenID Connect

Para escenarios de autenticación y autorización más complejos, considere usar OAuth2 y OpenID Connect. Estos estándares proporcionan un marco robusto para delegar el acceso a los recursos sin compartir credenciales. OAuth2 es principalmente un protocolo de autorización, mientras que OpenID Connect se basa en OAuth2 para proporcionar servicios de autenticación. Varios paquetes de Django, como `django-oauth-toolkit` y `django-allauth`, facilitan la integración de OAuth2 y OpenID Connect en sus APIs DRF.

Escenario de ejemplo: un usuario quiere otorgar a una aplicación de terceros acceso a sus datos almacenados en su API. Con OAuth2, el usuario puede autorizar la aplicación sin compartir su nombre de usuario y contraseña. En cambio, la aplicación recibe un token de acceso que puede usar para acceder a los datos del usuario dentro del alcance definido de los permisos.

Elegir el método de autenticación correcto

El mejor método de autenticación depende de sus requisitos específicos:

• Simplicidad y velocidad de implementación: La autenticación por token es generalmente más fácil de implementar inicialmente.
• Escalabilidad: La autenticación JWT es más escalable para APIs con mucho tráfico.
• Requisitos de seguridad: Considere la confidencialidad de sus datos y el nivel de seguridad requerido. OAuth2/OpenID Connect ofrece las funciones de seguridad más sólidas, pero requiere una implementación más compleja.
• Arquitectura de microservicios: Los JWT son adecuados para microservicios, ya que cada servicio puede verificar los tokens de forma independiente.

Mejores prácticas para la autenticación de API

• Use HTTPS: Siempre use HTTPS para cifrar la comunicación entre el cliente y el servidor, protegiendo las credenciales de las escuchas indiscretas.
• Almacene los secretos de forma segura: Nunca almacene claves secretas o contraseñas en texto sin formato. Use variables de entorno o herramientas de administración de configuración segura.
• Implemente la limitación de frecuencia: Proteja su API del abuso implementando la limitación de frecuencia para restringir la cantidad de solicitudes que un cliente puede realizar dentro de un período de tiempo determinado.
• Valide la entrada: Valide a fondo todos los datos de entrada para evitar ataques de inyección.
• Supervise y registre: Supervise su API en busca de actividad sospechosa y registre los eventos de autenticación con fines de auditoría.
• Actualice periódicamente las bibliotecas: Mantenga actualizadas sus bibliotecas de Django, DRF y autenticación para beneficiarse de los parches y mejoras de seguridad.
• Implemente CORS (Compartir recursos entre orígenes): Configure correctamente CORS para permitir que solo los dominios de confianza accedan a su API desde navegadores web.

Conclusión

Seleccionar el método de autenticación adecuado es crucial para proteger sus APIs DRF. La autenticación por token ofrece simplicidad, mientras que la autenticación JWT proporciona escalabilidad y flexibilidad. Comprender las ventajas y desventajas de cada método, junto con las mejores prácticas para la seguridad de la API, le permitirá crear APIs robustas y seguras que protejan sus datos y usuarios.

Recuerde considerar sus necesidades específicas y elegir la solución que equilibre mejor la seguridad, el rendimiento y la facilidad de implementación. Explore OAuth2 y OpenID Connect para escenarios de autorización más complejos.