Estoy tratando de envolver mi cabeza alrededor de la autenticación basada en JWT (token web JSON) para asegurar los puntos finales de API utilizando tokens de acceso. Estoy protegiendo estos puntos finales al requerir que el usuario tenga un token de acceso válido para obtener dichos recursos.
Sin embargo, estoy teniendo problemas para entender el uso de tokens de actualización.
Tengo un punto final / auth / login que acepta POST peticiones:
class UserLogin(Resource):
def post(self):
data = parser.parse_args()
current_user = User.find_by_username(data['username'])
if not current_user:
return {'message': 'Unsuccessful. You do not have an account'}
if User.verify_hash(data['password'], current_user.password):
access_token = create_access_token(current_user)
refresh_token = create_refresh_token(current_user)
return {
'message': 'Login successful {}'.format(current_user.username),
'roles': 'Role: {}'.format(current_user.role),
'access token': access_token,
'refresh token': refresh_token
}
else:
return {'message': 'Something went wrong'}
El punto final esencialmente verifica las credenciales entrantes para asegurar que el usuario exista en mi almacén de usuarios. Si lo hacen, devolveré un token de acceso y actualización. De lo contrario, un mensaje de error para ser manejado por el lado del cliente.
Ahora, suponga que el usuario ha iniciado sesión e intenta acceder a un recurso privado desde otro punto final asegurado al requerir un token de acceso. El cliente realizará una solicitud y el punto final protegido devolverá un mensaje de error que indica que no tiene un token de acceso. El cliente intentará generar un nuevo token de acceso utilizando el token de actualización obtenido al iniciar sesión:
class TokenRefresh(Resource):
@jwt_refresh_token_required
def post(self):
current_user = get_jwt_identity()
access_token = create_access_token(identity=current_user)
return {'access token': access_token}
Al golpear el recurso anterior se generará un nuevo token de acceso con un tiempo de caducidad definido. Este es mi flujo actual.
Mi pregunta es, ¿cómo debo almacenar los tokens de actualización para garantizar que el usuario autenticado acceda a ellos? ¿Debo tener alguna lógica adicional en mis solicitudes de inicio de sesión que almacene el token de actualización generado para ese usuario específico?
Si es así, ¿debería generar un nuevo token de actualización y sobrescribir el token de actualización adjunto al usuario cada vez que el cliente intente actualizar su token de acceso?
Actualmente, siento que mi proceso puede verse comprometido si un atacante logra obtener el token de actualización.