我可以强制注销JWT令牌或使其过期吗？

Question

对于身份验证，目前我们使用JWT，因此一旦创建了令牌，它就会在整个生命周期内创建，如果我们设置了时间过期，令牌将过期。

有没有办法使令牌过期？

单击注销按钮时，我需要销毁令牌。

我正在使用ASP. NET Core WebAPI。

Answer 1

实际上，最好的注销方法就是从客户端删除令牌。您可以缩短令牌的生存期（5-15分钟），并实现刷新令牌以增加安全性。在这种情况下，攻击者对您的JWT进行操作的可能性较小

Answer 2

我认为取消JWT是处理注销的最佳方式Piotr在他的博客中解释得很好：取消JWT代币

我们将从界面开始：

public interface ITokenManager
{
    Task<bool> IsCurrentActiveToken();
    Task DeactivateCurrentAsync();
    Task<bool> IsActiveAsync(string token);
    Task DeactivateAsync(string token);
}

并对其实现进行处理，其基本思想是只跟踪停用的令牌，并在不再需要时将其从缓存中删除（也就是说当过期时间过去时）——它们无论如何都将不再有效。

public class TokenManager : ITokenManager
{
    private readonly IDistributedCache _cache;
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly IOptions<JwtOptions> _jwtOptions;
 
    public TokenManager(IDistributedCache cache,
            IHttpContextAccessor httpContextAccessor,
            IOptions<JwtOptions> jwtOptions
        )
    {
        _cache = cache;
        _httpContextAccessor = httpContextAccessor;
        _jwtOptions = jwtOptions;
    }
 
    public async Task<bool> IsCurrentActiveToken()
        => await IsActiveAsync(GetCurrentAsync());
 
    public async Task DeactivateCurrentAsync()
        => await DeactivateAsync(GetCurrentAsync());
 
    public async Task<bool> IsActiveAsync(string token)
        => await _cache.GetStringAsync(GetKey(token)) == null;
 
    public async Task DeactivateAsync(string token)
        => await _cache.SetStringAsync(GetKey(token),
            " ", new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow =
                    TimeSpan.FromMinutes(_jwtOptions.Value.ExpiryMinutes)
            });
 
    private string GetCurrentAsync()
    {
        var authorizationHeader = _httpContextAccessor
            .HttpContext.Request.Headers["authorization"];
 
        return authorizationHeader == StringValues.Empty
            ? string.Empty
            : authorizationHeader.Single().Split(" ").Last();
    }
    
    private static string GetKey(string token)
        => $"tokens:{token}:deactivated";
}

如您所见，有两个助手方法将使用当前的HttpContext，以使事情变得更加简单。

接下来，让我们创建一个中间件来检查令牌是否已停用。这就是为什么我们应该将它们保存在缓存中的原因——用每个请求访问数据库可能迟早会杀死您的应用程序（或者至少让它变得非常非常慢）：

public class TokenManagerMiddleware : IMiddleware
{
    private readonly ITokenManager _tokenManager;
 
    public TokenManagerMiddleware(ITokenManager tokenManager)
    {
        _tokenManager = tokenManager;
    }
    
    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        if (await _tokenManager.IsCurrentActiveToken())
        {
            await next(context);
            
            return;
        }
        context.Response.StatusCode = (int) HttpStatusCode.Unauthorized;
    }
}

最后，让我们实现一个用于取消令牌的endpoint来结束我们的旅程：

[HttpPost("tokens/cancel")]
public async Task<IActionResult> CancelAccessToken()
{
    await _tokenManager.DeactivateCurrentAsync();
 
    return NoContent();
}

当然，我们可以通过通过URL传递令牌或一次取消所有现有的用户令牌（这需要额外的实现来跟踪它们）来使其更加复杂，但这是一个基本的示例。

确保将在容器中注册所需的依赖项并配置中间件：

public void ConfigureServices(IServiceCollection services)
{
    ...
    services.AddTransient<TokenManagerMiddleware>();
    services.AddTransient<ITokenManager, Services.TokenManager>();
    services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
    services.AddDistributedRedisCache(r => { r.Configuration = Configuration["redis:connectionString"]; 
    ...
}
 
public void Configure(IApplicationBuilder app, IHostingEnvironment env,
    ILoggerFactory loggerFactory)
{
    ...
    app.UseAuthentication();
    app.UseMiddleware<TokenManagerMiddleware>();
    app.UseMvc();
}

并在appsettings中为Redis提供配置。json文件：

"redis": {
  "connectionString": "localhost"
}

现在试着运行应用程序并调用令牌取消（sic）endpoint–就是这样。