He estado mirando tutorial tras tutorial sobre cómo proteger su .NET Core WebAPI con tokens de autenticación y todo parece requerir una combinación de nombre de usuario / contraseña para obtener un token temporal para usar para autenticar contra controladores API.

El proyecto en el que estoy trabajando está usando dispositivos Windows IOT que ejecutan una aplicación UWP personalizada que escribí que necesita conectarse a esta API en segundo plano para registrar datos y desplegar las últimas configuraciones de dispositivos.

Había planeado darle a cada dispositivo un token único para la autenticación que se ingresará y almacenará durante la configuración inicial del dispositivo / aplicación. La mayoría de las API de terceros con las que he trabajado solo te emiten un token permanente que puedes usar para acceder a sus API. Quería hacer algo similar.

0
JoeyZero 23 feb. 2018 a las 09:46

2 respuestas

La mejor respuesta

JWT parecía excesivo y demasiado complejo para mis propósitos, así que terminé optando por una solución de middleware siguiendo este tutorial: https://www.youtube.com/watch?v=n0llyujNGw8

Terminé creando una clase de middleware con el siguiente código:

public class TokenValidationMiddleware
{
    private readonly RequestDelegate _next;

    public TokenValidationMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        bool validToken = false;

        //Require HTTPS
        if (context.Request.IsHttps)
        {
            //Skip token authentication for test controller
            if (context.Request.Path.StartsWithSegments("/api/values"))
            {
                validToken = true;
            }

            //Token header exists in the request
            if (context.Request.Headers.ContainsKey("Token"))
            {
                //Check for a valid device by API token in my DB and set validToken to true if found
                if (repository.FindDeviceByAPIKey())
                {
                    validToken = true;
                }
            }

            if (!validToken)
            {
                context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
                await context.Response.WriteAsync("Invalid Token");
            }
            else
            {
                await _next.Invoke(context);
            }
        }
        else
        {
            context.Response.StatusCode = (int)HttpStatusCode.HttpVersionNotSupported;
            await context.Response.WriteAsync("HTTP not supported");
        }
    }
}

public static class TokenExtensions
{
    public static IApplicationBuilder UseTokenAuth(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<TokenValidationMiddleware>();
    }
}

Luego acabo de agregar app.UseTokenAuth (); a mi clase de inicio

0
JoeyZero 9 jul. 2018 a las 23:06

Puede utilizar un enfoque JWT estándar, creando dos tokens en el inicio de sesión con nombre de usuario / contraseña.

El primer token (token de acceso) es de corta duración y contiene privilegios para acceder a los puntos finales de inicio de sesión de su empresa. El segundo (Refresh token) es permanente y le permite adquirir un nuevo token de acceso, una vez que ha expirado, creando un patrón de acceso continuo. El token de actualización solo debe incluir un reclamo de actualización , que le permitiría acceder al punto final utilizado específicamente para crear un nuevo token de corta duración.

Hay toneladas de tutoriales, como http: // piotrgankiewicz.com/2017/12/07/jwt-refresh-tokens-and-net-core/

0
Milan Vidakovic 23 feb. 2018 a las 09:52