JWT-токен в cookie в ASP.Net Core: максимальная безопасность и контроль

			services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(options =>  
{  
	// выставляем настройки под нужды своего проекта, здесь просто пример
   options.TokenValidationParameters = new TokenValidationParameters()  
   {  
      ValidateIssuer = true,  
      ValidIssuer = issuer,  
      ValidateAudience = true,  
      ValidAudience = audience,  
      ValidateLifetime = true,  
      ValidateIssuerSigningKey = true,  
      IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(issuerSigningKey))  
   };
   
   // здесь и происходит перевод токена из cookie в контекст
   options.Events = new JwtBearerEvents  
   {  
      OnMessageReceived = context =>  
      {  
         if(context.Request.Cookies.ContainsKey(Constants.TokenCookieName))  
            context.Token = context.Request.Cookies[Constants.TokenCookieName];  
         return Task.CompletedTask;  
      }   
   };
});

		

			/// <summary>  
///       Вход в систему  
/// </summary>  
[HttpPost("login")]  
[AllowAnonymous]  
public async Task<ActionResult<LoginResponse>> Login([FromBody] LoginRequest request)  
{  
   var authResult = _authService.Authenticate(request.Login, request.Password);  
   if (!authResult.Success)  
   {      
	  ClearTokenCookie();  // стираем авторизационный куки
      return Unauthorized(new ProblemDetails  
      {  
         Title = "Ошибка",  
         Detail = "Неправильные логин или пароль",  
      });  
   }   
  
   var sessionId = Guid.NewGuid().ToString();  
   var token = _jwtService.CreateToken(sessionId, authResult.Login, authResult.Roles);  
   Response.Cookies.Append(Constants.TokenCookieName, token, new CookieOptions  
   {  
      Expires = DateTimeOffset.Now.AddMinutes(_options.ExpirationTime),  
      SameSite = SameSiteMode.Strict,  
      HttpOnly = true,  
	  Secure = true
   });  
  
   var antiForgeryToken = _antiForgery.CreateToken(sessionId, authResult.Login, authResult.Roles);  
  
   return Ok(new LoginResponse { Token = antiForgeryToken });  
}

/// <summary>  
///       Выход из системы  
/// </summary>  
/// <returns></returns>  
[HttpPost("logout")]  
[AllowAnonymous]  
public ActionResult Logout()  
{  
   ClearTokenCookie();  
   return Ok();  
}  
  
private void ClearTokenCookie()  
{  
   if (Request.Cookies.ContainsKey(Constants.TokenCookieName))  
   {   
      Response.Cookies.Delete(Constants.TokenCookieName);  
   }
}

		

			public string CreateToken(string sessionId, string login, params string[] roles)  
{  
   var claims = new List<Claim>  
   {      
      new(ClaimsIdentity.DefaultNameClaimType, login),  
      new(Constants.SessionIdClaimType, sessionId),  
   };  
  
   claims.AddRange(roles.Select(x => new Claim(ClaimsIdentity.DefaultRoleClaimType, x)));  
  
   return CreateToken(claims);  
}  
   
private string CreateToken(IEnumerable<Claim> claims)  
{  
   var notBefore = DateTime.UtcNow;  
   var expires = notBefore.Add(TimeSpan.FromMinutes(_options.ExpirationTime));  
   var securityKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_options.Key));  
   var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);  
   var jwt = new JwtSecurityToken(_options.Issuer, _options.Audience, claims, notBefore, expires, credentials);  
   var tokenHandler = new JwtSecurityTokenHandler();  
  
   return tokenHandler.WriteToken(jwt);  
}
		

			internal class AntiForgeryMiddleware  
{  
   private readonly RequestDelegate _next;  
   private readonly ILogger<AntiForgeryMiddleware> _logger;  
  
   public AntiForgeryMiddleware(RequestDelegate next, ILogger<AntiForgeryMiddleware> logger)  
   {      
      _next = next ?? throw new ArgumentNullException(nameof(next));  
      _logger = logger;  
   }
     
   public async Task Invoke(HttpContext context, IAntiForgeryService service)  
   {      
	  var endpoint = context.Features.Get<IEndpointFeature>()?.Endpoint;  
      var attribute = endpoint?.Metadata.GetMetadata<AuthorizeAttribute>();  
      if (attribute is null)  
      {        
         await _next(context);  
         return;  
      }  
      if (!TokenPassed(context, service))  
      {         
         _logger.LogError("Передан недействительный AntiForgery-токен.");  
         context.Response.StatusCode = (int)HttpStatusCode.BadRequest;  
         return;  
      }  
      await _next(context);  
   }  
   
   private static bool TokenPassed(HttpContext context, IAntiForgeryService service)  
   {      
      if (!context.Request.Headers.TryGetValue(Constants.XsrfTokenHeader, out var tokenHeader))  
      {         
         return false;  
      }  

	  // переданный токен берем из заголовков
      var token = tokenHeader.FirstOrDefault() ?? string.Empty;  
	  
	  // необходимые для проверки токена поля берем из Claims
	  var login = context.User.Claims.FirstOrDefault(x => x.Type == ClaimsIdentity.DefaultNameClaimType)?.Value ?? string.Empty;  
	  var roles = context.User.Claims.Where(x => x.Type == ClaimsIdentity.DefaultRoleClaimType).Select(x => x.Value).ToArray();  
	  var sessionId = context.User.Claims.FirstOrDefault(x => x.Type == Constants.SessionIdClaimType)?.Value ?? string.Empty;  
	  
	  return service.CheckToken(token, sessionId, login, roles);
   }
}
		

			internal class RefreshTokenMiddleware  
{  
   private readonly RequestDelegate _next;  
   private readonly ILogger<RefreshTokenMiddleware> _logger;  
    
   public RefreshTokenMiddleware(RequestDelegate next, ILogger<RefreshTokenMiddleware> logger)  
   {      
	  _next = next ?? throw new ArgumentNullException(nameof(next));  
      _logger = logger;  
   }
     
   public async Task Invoke(HttpContext context, IJwtService jwtService, IOptions<AuthOptions> options)  
   {      
      if (!context.Request.Cookies.ContainsKey(Constants.TokenCookieName))  
      {         
         await _next(context);  
         return;  
      }      
      var jwtCookie = context.Request.Cookies[Constants.TokenCookieName]!;  
  
      try  
      {  
         // создаем новый токен на основе существующего
         var token = jwtService.RefreshToken(jwtCookie);  

		 // подменяем cookie - теперь там будет лежать обновленный токен
         context.Response.Cookies.Append(Constants.TokenCookieName, token, new CookieOptions  
         {  
            Expires = DateTimeOffset.Now.AddMinutes(options.Value.ExpirationTime),             SameSite = SameSiteMode.Strict,  
            HttpOnly = true,
            Secure = true
         });  
      }      
      catch (Exception ex)  
      {         
         _logger.LogError(ex, "Ошибка обновления токена");  
      }      
      finally  
      {  
         await _next(context);  
      }   
   }
}