Аутентификация и авторизация JWT в микросервисах с API Gateway

private string GenerateJwtSignature(string encodedHeader, string encodedPayload, byte[] secretKey)
{
    var stringToSign = $"{encodedHeader}.{encodedPayload}";
    var bytesToSign = Encoding.UTF8.GetBytes(stringToSign);
    
    using (var hmac = new HMACSHA256(secretKey))
    {
        var signature = hmac.ComputeHash(bytesToSign);
        return Base64UrlEncode(signature);
    }
}

private string GenerateJwtSignature(string encodedHeader, string encodedPayload, RSAParameters privateKey)
{
    var stringToSign = $"{encodedHeader}.{encodedPayload}";
    var bytesToSign = Encoding.UTF8.GetBytes(stringToSign);
    
    using (var rsa = new RSACryptoServiceProvider())
    {
        rsa.ImportParameters(privateKey);
        var signature = rsa.SignData(bytesToSign, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
        return Base64UrlEncode(signature);
    }
}

// Пример получения JWT-секрета из Azure Key Vault
var secretClient = new SecretClient(
    new Uri("https://your-key-vault.vault.azure.net/"),
    new DefaultAzureCredential());
 
KeyVaultSecret secret = await secretClient.GetSecretAsync("JwtSigningKey");
byte[] signingKey = Convert.FromBase64String(secret.Value);

// Пример выбора алгоритма при настройке JWT в ASP.NET Core
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            // Для HS256:
            IssuerSigningKey = new SymmetricSecurityKey(secretKey),
            // Для RS256:
            // IssuerSigningKey = new RsaSecurityKey(rsaParameters),
            ValidateIssuer = true,
            ValidIssuer = "your-issuer",
            ValidateAudience = true,
            ValidAudience = "your-audience",
            ValidateLifetime = true,
            ClockSkew = TimeSpan.Zero
        };
    });

[ApiController]
[Route("api/auth")]
public class AuthController : ControllerBase
{
    private readonly JwtTokenGenerator _tokenGenerator;
    private readonly IUserRepository _userRepository;
    
    public AuthController(JwtTokenGenerator tokenGenerator, IUserRepository userRepository)
    {
        _tokenGenerator = tokenGenerator;
        _userRepository = userRepository;
    }
    
    [HttpPost("login")]
    public async Task<IActionResult> Login(LoginRequest loginRequest)
    {
        // Проверка учётных данных пользователя
        var user = await _userRepository.GetByUsernameAsync(loginRequest.Username);
        
        if (user == null || !VerifyPassword(loginRequest.Password, user.PasswordHash))
        {
            return Unauthorized();
        }
        
        // Генерация JWT токена
        var token = _tokenGenerator.GenerateToken(user);
        
        return Ok(new { token });
    }
}

public class JwtTokenGenerator
{
    private readonly IOptions<JwtOptions> _jwtOptions;
    
    public JwtTokenGenerator(IOptions<JwtOptions> jwtOptions)
    {
        _jwtOptions = jwtOptions;
    }
    
    public string GenerateToken(User user)
    {
        var claims = new List<Claim>
        {
            new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
            new Claim(ClaimTypes.Name, user.Username),
            new Claim(ClaimTypes.Email, user.Email)
        };
        
        // Добавление ролей пользователя
        foreach (var role in user.Roles)
        {
            claims.Add(new Claim(ClaimTypes.Role, role));
        }
        
        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtOptions.Value.SecretKey));
        var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
        
        var token = new JwtSecurityToken(
            issuer: _jwtOptions.Value.Issuer,
            audience: _jwtOptions.Value.Audience,
            claims: claims,
            expires: DateTime.UtcNow.AddHours(_jwtOptions.Value.ExpiryHours),
            signingCredentials: credentials
        );
        
        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

public class ExternalIdentityService : IIdentityService
{
    private readonly HttpClient _httpClient;
    private readonly IOptions<IdentityServerOptions> _options;
    
    public ExternalIdentityService(HttpClient httpClient, IOptions<IdentityServerOptions> options)
    {
        _httpClient = httpClient;
        _options = options;
    }
    
    public async Task<TokenResponse> GetTokenAsync(string username, string password)
    {
        var discoveryDocument = await _httpClient.GetDiscoveryDocumentAsync(_options.Value.Authority);
        
        if (discoveryDocument.IsError)
        {
            throw new Exception($"Discovery document error: {discoveryDocument.Error}");
        }
        
        var tokenResponse = await _httpClient.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = discoveryDocument.TokenEndpoint,
            ClientId = _options.Value.ClientId,
            ClientSecret = _options.Value.ClientSecret,
            Scope = "openid profile api1",
            UserName = username,
            Password = password
        });
        
        if (tokenResponse.IsError)
        {
            throw new Exception($"Token request error: {tokenResponse.Error}");
        }
        
        return tokenResponse;
    }
}

var builder = WebApplication.CreateBuilder(args);
 
// Настройка JWT-аутентификации
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer("Bearer", options =>
    {
        options.Authority = "https://auth-service.example.com";
        options.RequireHttpsMetadata = false;
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = "auth-service",
            ValidAudience = "api-gateway",
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:SecretKey"]))
        };
    });
 
// Добавление Ocelot
builder.Services.AddOcelot();
 
var app = builder.Build();
 
// Подключение middleware
app.UseAuthentication();
app.UseAuthorization();
app.UseOcelot().Wait();
 
app.Run();

public class JwtValidationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ITokenValidator _tokenValidator;
    private readonly ILogger<JwtValidationMiddleware> _logger;
 
    public JwtValidationMiddleware(
        RequestDelegate next, 
        ITokenValidator tokenValidator,
        ILogger<JwtValidationMiddleware> logger)
    {
        _next = next;
        _tokenValidator = tokenValidator;
        _logger = logger;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Пропускаем аутентификацию для эндпойнтов авторизации
        if (context.Request.Path.StartsWithSegments("/api/auth"))
        {
            await _next(context);
            return;
        }
 
        // Получаем токен из заголовка Authorization
        var authHeader = context.Request.Headers["Authorization"].FirstOrDefault();
        if (authHeader == null || !authHeader.StartsWith("Bearer "))
        {
            context.Response.StatusCode = 401; // Unauthorized
            return;
        }
 
        string token = authHeader.Substring("Bearer ".Length).Trim();
 
        try
        {
            // Валидация токена
            var validationResult = _tokenValidator.ValidateToken(token);
            if (!validationResult.IsValid)
            {
                _logger.LogWarning("Invalid token: {Reason}", validationResult.FailureReason);
                context.Response.StatusCode = 401;
                return;
            }
 
            // Добавляем клеймы пользователя в контекст
            context.User = validationResult.ClaimsPrincipal;
            
            // Добавляем информацию о пользователе в заголовки для микросервисов
            context.Request.Headers.Add("X-User-Id", validationResult.UserId);
            context.Request.Headers.Add("X-User-Roles", validationResult.Roles);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Exception during token validation");
            context.Response.StatusCode = 401;
            return;
        }
 
        await _next(context);
    }
}

public class TokenValidator : ITokenValidator
{
    private readonly HttpClient _httpClient;
    private readonly IOptions<TokenValidationOptions> _options;
 
    public TokenValidator(HttpClient httpClient, IOptions<TokenValidationOptions> options)
    {
        _httpClient = httpClient;
        _options = options;
    }
 
    public async Task<TokenValidationResult> ValidateTokenAsync(string token)
    {
        var request = new HttpRequestMessage(HttpMethod.Post, _options.Value.ValidationEndpoint)
        {
            Content = new StringContent(JsonSerializer.Serialize(new { token }), 
                Encoding.UTF8, 
                "application/json")
        };
 
        var response = await _httpClient.SendAsync(request);
        if (!response.IsSuccessStatusCode)
        {
            return TokenValidationResult.Failed("Token validation service returned error");
        }
 
        var content = await response.Content.ReadAsStringAsync();
        var result = JsonSerializer.Deserialize<TokenValidationResponseDto>(content);
        
        if (!result.IsValid)
        {
            return TokenValidationResult.Failed(result.ErrorMessage);
        }
 
        // Создаем ClaimsPrincipal из валидированных клеймов
        var claims = result.Claims.Select(c => new Claim(c.Type, c.Value)).ToList();
        var identity = new ClaimsIdentity(claims, "Bearer");
        var principal = new ClaimsPrincipal(identity);
 
        return TokenValidationResult.Success(principal, result.UserId, result.Roles);
    }
}

// В промежуточном ПО API Gateway после валидации JWT
var userId = principal.FindFirst(ClaimTypes.NameIdentifier)?.Value;
var roles = principal.FindAll(ClaimTypes.Role).Select(c => c.Value);
 
// Добавляем информацию в заголовки запроса
context.Request.Headers.Add("X-User-Id", userId);
context.Request.Headers.Add("X-User-Roles", string.Join(",", roles));

public class InternalAuthMiddleware
{
    private readonly RequestDelegate _next;
 
    public InternalAuthMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Получаем информацию о пользователе из заголовков
        if (context.Request.Headers.TryGetValue("X-User-Id", out var userIdValues) &&
            !string.IsNullOrEmpty(userIdValues))
        {
            var userId = userIdValues.First();
            var roles = context.Request.Headers["X-User-Roles"].ToString().Split(',');
 
            // Создаем claims для пользователя
            var claims = new List<Claim>
            {
                new Claim(ClaimTypes.NameIdentifier, userId)
            };
 
            foreach (var role in roles)
            {
                if (!string.IsNullOrWhiteSpace(role))
                {
                    claims.Add(new Claim(ClaimTypes.Role, role.Trim()));
                }
            }
 
            // Создаем ClaimsPrincipal и устанавливаем его в контекст
            var identity = new ClaimsIdentity(claims, "Internal");
            context.User = new ClaimsPrincipal(identity);
        }
 
        await _next(context);
    }
}

[HttpPost("refresh")]
public async Task<IActionResult> RefreshToken(RefreshTokenRequest request)
{
    // Проверка существования и валидности refresh-токена
    var storedToken = await _refreshTokenRepository.GetByTokenAsync(request.RefreshToken);
    
    if (storedToken == null || storedToken.ExpiryDate < DateTime.UtcNow || storedToken.IsRevoked)
    {
        return Unauthorized();
    }
    
    // Получение пользователя
    var user = await _userRepository.GetByIdAsync(storedToken.UserId);
    if (user == null)
    {
        return Unauthorized();
    }
    
    // Генерация нового access token
    var accessToken = _tokenGenerator.GenerateToken(user);
    
    // Опционально: генерация нового refresh token и удаление старого
    var newRefreshToken = _tokenGenerator.GenerateRefreshToken();
    await _refreshTokenRepository.RevokeTokenAsync(storedToken.Id);
    await _refreshTokenRepository.AddTokenAsync(new RefreshToken
    {
        Token = newRefreshToken,
        UserId = user.Id,
        ExpiryDate = DateTime.UtcNow.AddDays(30)
    });
    
    return Ok(new
    {
        accessToken,
        refreshToken = newRefreshToken
    });
}

public class JwtService : IJwtService
{
    private readonly JwtSettings _jwtSettings;
    private readonly ILogger<JwtService> _logger;
 
    public JwtService(IOptions<JwtSettings> jwtSettings, ILogger<JwtService> logger)
    {
        _jwtSettings = jwtSettings.Value;
        _logger = logger;
    }
 
    public string GenerateAccessToken(UserDto user)
    {
        var key = Encoding.ASCII.GetBytes(_jwtSettings.Secret);
        var symmetricKey = new SymmetricSecurityKey(key);
        var signingCredentials = new SigningCredentials(symmetricKey, SecurityAlgorithms.HmacSha256);
 
        var claims = new List<Claim>
        {
            new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
            new Claim(JwtRegisteredClaimNames.Email, user.Email),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
            new Claim("tenant_id", user.TenantId.ToString())
        };
 
        // Добавляем роли пользователя
        foreach (var role in user.Roles)
        {
            claims.Add(new Claim(ClaimTypes.Role, role));
        }
 
        // Добавляем кастомные разрешения
        foreach (var permission in user.Permissions)
        {
            claims.Add(new Claim("permission", permission));
        }
 
        var tokenDescriptor = new SecurityTokenDescriptor
        {
            Subject = new ClaimsIdentity(claims),
            Expires = DateTime.UtcNow.AddMinutes(_jwtSettings.AccessTokenExpirationMinutes),
            Issuer = _jwtSettings.Issuer,
            Audience = _jwtSettings.Audience,
            SigningCredentials = signingCredentials
        };
 
        var tokenHandler = new JwtSecurityTokenHandler();
        var token = tokenHandler.CreateToken(tokenDescriptor);
 
        _logger.LogInformation("Generated JWT token for user {UserId}", user.Id);
        return tokenHandler.WriteToken(token);
    }
 
    public string GenerateRefreshToken()
    {
        var randomNumber = new byte[32];
        using var rng = RandomNumberGenerator.Create();
        rng.GetBytes(randomNumber);
        return Convert.ToBase64String(randomNumber);
    }
}

public ClaimsPrincipal ValidateToken(string token)
{
    var tokenHandler = new JwtSecurityTokenHandler();
    var key = Encoding.ASCII.GetBytes(_jwtSettings.Secret);
    
    try
    {
        var validationParameters = new TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(key),
            ValidateIssuer = true,
            ValidIssuer = _jwtSettings.Issuer,
            ValidateAudience = true,
            ValidAudience = _jwtSettings.Audience,
            ValidateLifetime = true,
            ClockSkew = TimeSpan.Zero // Для строгой проверки времени
        };
 
        var principal = tokenHandler.ValidateToken(token, validationParameters, out _);
        return principal;
    }
    catch (SecurityTokenExpiredException)
    {
        _logger.LogWarning("Token expired");
        throw new AuthenticationException("Token expired");
    }
    catch (SecurityTokenInvalidSignatureException)
    {
        _logger.LogWarning("Invalid token signature");
        throw new AuthenticationException("Invalid token signature");
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Token validation failed");
        throw new AuthenticationException("Token validation failed");
    }
}

public class TokenExpirationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ITokenRefreshService _tokenRefreshService;
    private readonly ILogger<TokenExpirationMiddleware> _logger;
 
    public TokenExpirationMiddleware(
        RequestDelegate next,
        ITokenRefreshService tokenRefreshService,
        ILogger<TokenExpirationMiddleware> logger)
    {
        _next = next;
        _tokenRefreshService = tokenRefreshService;
        _logger = logger;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (SecurityTokenExpiredException)
        {
            _logger.LogInformation("Handling expired token");
            
            // Получаем refresh-токен из cookie или хранилища клиента
            var refreshToken = context.Request.Cookies["refresh_token"];
            if (string.IsNullOrEmpty(refreshToken))
            {
                context.Response.StatusCode = 401;
                await context.Response.WriteAsJsonAsync(new { error = "Token expired" });
                return;
            }
 
            try
            {
                // Пытаемся обновить токен
                var tokenResponse = await _tokenRefreshService.RefreshTokenAsync(refreshToken);
                
                // Устанавливаем новые токены в куки
                context.Response.Cookies.Append("access_token", tokenResponse.AccessToken, 
                    new CookieOptions { HttpOnly = true, Secure = true, SameSite = SameSiteMode.Strict });
                context.Response.Cookies.Append("refresh_token", tokenResponse.RefreshToken, 
                    new CookieOptions { HttpOnly = true, Secure = true, SameSite = SameSiteMode.Strict });
                
                // Повторяем запрос с новым токеном
                context.Request.Headers["Authorization"] = $"Bearer {tokenResponse.AccessToken}";
                
                // Повторно вызываем конвейер middleware
                await _next(context);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Token refresh failed");
                context.Response.StatusCode = 401;
                await context.Response.WriteAsJsonAsync(new { error = "Authentication failed" });
            }
        }
    }
}

public class TokenBlacklistService : ITokenBlacklistService
{
    private readonly IDistributedCache _cache;
    private readonly ILogger<TokenBlacklistService> _logger;
 
    public TokenBlacklistService(IDistributedCache cache, ILogger<TokenBlacklistService> logger)
    {
        _cache = cache;
        _logger = logger;
    }
 
    public async Task BlacklistTokenAsync(string token, string reason)
    {
        // Парсим токен для получения его идентификатора и времени истечения
        var tokenHandler = new JwtSecurityTokenHandler();
        var jwtToken = tokenHandler.ReadJwtToken(token);
        
        var jti = jwtToken.Claims.FirstOrDefault(c => c.Type == JwtRegisteredClaimNames.Jti)?.Value;
        var exp = jwtToken.Claims.FirstOrDefault(c => c.Type == JwtRegisteredClaimNames.Exp)?.Value;
        
        if (string.IsNullOrEmpty(jti))
        {
            _logger.LogWarning("Cannot blacklist token: missing jti claim");
            return;
        }
 
        // Преобразуем время экспирации из Unix timestamp в DateTime
        var expiry = DateTimeOffset.FromUnixTimeSeconds(long.Parse(exp ?? "0"));
        var timeToLive = expiry - DateTimeOffset.UtcNow;
        
        // Если токен уже истек, нет смысла добавлять его в черный список
        if (timeToLive <= TimeSpan.Zero)
        {
            _logger.LogInformation("Token already expired, no need to blacklist");
            return;
        }
 
        // Добавляем токен в черный список (Redis или другой распределенный кэш)
        await _cache.SetStringAsync(
            $"blacklist:{jti}", 
            reason, 
            new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = timeToLive + TimeSpan.FromMinutes(5) }
        );
        
        _logger.LogInformation("Token {TokenId} blacklisted. Reason: {Reason}", jti, reason);
    }
 
    public async Task<bool> IsTokenBlacklistedAsync(string jti)
    {
        var blacklisted = await _cache.GetStringAsync($"blacklist:{jti}");
        return blacklisted != null;
    }
}

public class TokenClient : ITokenClient
{
    private readonly HttpClient _httpClient;
    private readonly TokenClientOptions _options;
    private readonly ILogger<TokenClient> _logger;
 
    public TokenClient(
        HttpClient httpClient, 
        IOptions<TokenClientOptions> options, 
        ILogger<TokenClient> logger)
    {
        _httpClient = httpClient;
        _options = options.Value;
        _logger = logger;
    }
 
    public async Task<TokenResponse> RequestClientCredentialsTokenAsync(string scope)
    {
        try
        {
            // Используем IdentityModel для получения токена
            var response = await _httpClient.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
            {
                Address = _options.TokenEndpoint,
                ClientId = _options.ClientId,
                ClientSecret = _options.ClientSecret,
                Scope = scope
            });
 
            if (response.IsError)
            {
                _logger.LogError("Error requesting token: {Error}, {ErrorDescription}", 
                    response.Error, response.ErrorDescription);
                throw new AuthenticationException($"Failed to obtain token: {response.Error}");
            }
 
            return response;
        }
        catch (Exception ex) when (ex is not AuthenticationException)
        {
            _logger.LogError(ex, "Unexpected error requesting token");
            throw new AuthenticationException("Failed to communicate with the identity server", ex);
        }
    }
}

public async Task<bool> ValidateExternalTokenAsync(string token, string provider)
{
    try
    {
        switch (provider.ToLowerInvariant())
        {
            case "google":
                return await ValidateGoogleTokenAsync(token);
            case "microsoft":
                return await ValidateMicrosoftTokenAsync(token);
            default:
                _logger.LogWarning("Unknown token provider: {Provider}", provider);
                return false;
        }
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error validating external token");
        return false;
    }
}
 
private async Task<bool> ValidateGoogleTokenAsync(string token)
{
    // Загружаем ключи проверки подписи с Google
    var discoveryDocument = await _httpClient.GetDiscoveryDocumentAsync("https://accounts.google.com");
    if (discoveryDocument.IsError)
    {
        _logger.LogError("Error loading Google discovery document: {Error}", discoveryDocument.Error);
        return false;
    }
 
    // Проверяем токен с использованием полученных ключей
    var validationParameters = new TokenValidationParameters
    {
        ValidateIssuerSigningKey = true,
        IssuerSigningKeys = discoveryDocument.KeySet.Keys,
        ValidateIssuer = true,
        ValidIssuer = "https://accounts.google.com",
        ValidateAudience = true,
        ValidAudience = _googleAuthOptions.ClientId,
        ValidateLifetime = true,
        ClockSkew = TimeSpan.FromMinutes(5)
    };
 
    var handler = new JwtSecurityTokenHandler();
    var result = handler.ValidateToken(token, validationParameters, out var validatedToken);
    
    return result != null && result.Identity.IsAuthenticated;
}

public string GenerateTokenForEcommerce(UserDto user)
{
    var claims = new List<Claim>
    {
        // Стандартные клеймы
        new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
        new Claim(JwtRegisteredClaimNames.Email, user.Email),
        
        // Бизнес-клеймы
        new Claim("subscription_level", user.SubscriptionPlan),
        new Claim("account_type", user.AccountType),
        new Claim("customer_segment", user.CustomerSegment)
    };
    
    // Добавляем информацию о последней покупке
    if (user.LastPurchase != null)
    {
        claims.Add(new Claim("last_purchase_date", 
            user.LastPurchase.Date.ToString("yyyy-MM-dd")));
        claims.Add(new Claim("last_purchase_amount", 
            user.LastPurchase.Amount.ToString(CultureInfo.InvariantCulture)));
    }
    
    // Добавляем список категорий интересов пользователя
    foreach (var interest in user.Interests)
    {
        claims.Add(new Claim("interest", interest));
    }
    
    // Добавляем лимиты скидок, доступных для пользователя
    claims.Add(new Claim("max_discount_percent", 
        user.MaxDiscountPercent.ToString(CultureInfo.InvariantCulture)));
        
    // Создаем токен с расширенными данными
    return CreateToken(claims);
}

public void ConfigureServices(IServiceCollection services)
{
    // Настройка политик авторизации
    services.AddAuthorization(options =>
    {
        // Простая политика на основе роли
        options.AddPolicy("AdminsOnly", policy =>
            policy.RequireRole("Admin"));
            
        // Комбинированная политика
        options.AddPolicy("SeniorSales", policy =>
            policy.RequireRole("Sales")
                  .RequireClaim("experience_years", "5", "6", "7", "8", "9", "10"));
                  
        // Политика на основе пользовательского требования
        options.AddPolicy("PremiumContent", policy =>
            policy.RequireAssertion(context => 
                context.User.HasClaim(c => c.Type == "subscription_level") &&
                (context.User.FindFirst("subscription_level").Value == "premium" ||
                 context.User.FindFirst("subscription_level").Value == "enterprise")));
                 
        // Динамическая политика с параметрами
        options.AddPolicy("MinimumOrderValue", policy =>
            policy.Requirements.Add(new MinimumOrderValueRequirement(100)));
    });
    
    // Регистрация обработчиков для пользовательских требований
    services.AddSingleton<IAuthorizationHandler, MinimumOrderValueHandler>();
}

public class MinimumOrderValueRequirement : IAuthorizationRequirement
{
    public decimal MinimumValue { get; }
    
    public MinimumOrderValueRequirement(decimal minimumValue)
    {
        MinimumValue = minimumValue;
    }
}
 
public class MinimumOrderValueHandler : AuthorizationHandler<MinimumOrderValueRequirement>
{
    private readonly IOrderService _orderService;
    
    public MinimumOrderValueHandler(IOrderService orderService)
    {
        _orderService = orderService;
    }
    
    protected override async Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        MinimumOrderValueRequirement requirement)
    {
        if (!context.User.Identity.IsAuthenticated)
        {
            return;
        }
        
        var userId = context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        if (string.IsNullOrEmpty(userId))
        {
            return;
        }
        
        var orderValue = await _orderService.GetUserTotalOrderValueAsync(userId);
        if (orderValue >= requirement.MinimumValue)
        {
            context.Succeed(requirement);
        }
    }
}

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    [HttpGet("premium")]
    [Authorize(Policy = "PremiumContent")]
    public IActionResult GetPremiumProducts()
    {
        // Логика доступа к премиум-продуктам
        return Ok(new { premium = true, products = _productService.GetPremiumProducts() });
    }
    
    [HttpGet("discounts")]
    [Authorize(Policy = "MinimumOrderValue")]
    public IActionResult GetSpecialDiscounts()
    {
        // Специальные скидки для пользователей с высоким объемом заказов
        return Ok(new { discounts = _discountService.GetSpecialDiscounts() });
    }
}

// Неправильно: отсутствие проверки алгоритма
var validationParameters = new TokenValidationParameters
{
    ValidateIssuer = true,
    ValidIssuer = "trusted-issuer",
    ValidateAudience = true,
    ValidAudience = "my-audience"
    // Отсутствует проверка подписи!
};

// Антипаттерн: жестко закодированный секрет
public static string SecretKey = "MySuperSecretKey12345";

// Правильный подход с использованием Azure Key Vault
var keyVaultClient = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(
    async (authority, resource, scope) =>
    {
        var azureServiceTokenProvider = new AzureServiceTokenProvider();
        return await azureServiceTokenProvider.GetAccessTokenAsync(resource);
    }));
 
var secret = await keyVaultClient.GetSecretAsync(
    "https://mykeyvault.vault.azure.net/secrets/JwtSecret");
var secretBytes = Convert.FromBase64String(secret.Value);

// Полная валидация токена
var validationParameters = new TokenValidationParameters
{
    ValidateIssuerSigningKey = true,
    IssuerSigningKey = new SymmetricSecurityKey(secretKey),
    ValidateIssuer = true,
    ValidIssuer = "auth-service",
    ValidateAudience = true,
    ValidAudience = "product-service",
    ValidateLifetime = true,
    ClockSkew = TimeSpan.Zero
};

// Слишком долгий срок жизни токена
new JwtSecurityToken(
    expires: DateTime.UtcNow.AddMonths(3), // Опасно!
    ...
)

public async Task<TokenValidationResult> ValidateTokenAsync(string token)
{
    // Попытка получить результат из кэша
    var cacheKey = $"token_validation:{ComputeHash(token)}";
    var cachedResult = await _distributedCache.GetStringAsync(cacheKey);
    
    if (!string.IsNullOrEmpty(cachedResult))
    {
        return JsonSerializer.Deserialize<TokenValidationResult>(cachedResult);
    }
    
    // Валидация токена
    var result = await PerformTokenValidationAsync(token);
    
    // Сохранение результата в кэше (если токен валиден)
    if (result.IsValid)
    {
        await _distributedCache.SetStringAsync(
            cacheKey,
            JsonSerializer.Serialize(result),
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
            });
    }
    
    return result;
}

public class JwtMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ITokenValidator _tokenValidator;
    
    public JwtMiddleware(RequestDelegate next, ITokenValidator tokenValidator)
    {
        _next = next;
        _tokenValidator = tokenValidator;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        var token = context.Request.Headers["Authorization"]
            .FirstOrDefault()?.Split(" ").Last();
            
        if (token != null)
        {
            await AttachUserToContextAsync(context, token);
        }
        
        await _next(context);
    }
    
    private async Task AttachUserToContextAsync(HttpContext context, string token)
    {
        try
        {
            var validationResult = await _tokenValidator.ValidateTokenAsync(token);
            if (validationResult.IsValid)
            {
                context.Items["User"] = validationResult.User;
            }
        }
        catch
        {
            // Обработка ошибок без блокировки запроса
        }
    }
}

// Пример правила для сканера уязвимостей
// Поиск жестко закодированных JWT в исходном коде
var securityRule = new SecurityRule {
    Id = "SEC001",
    Severity = Severity.Critical,
    Pattern = @"eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+",
    Message = "Обнаружен жестко закодированный JWT токен"
};

public class SecretRotationService : IHostedService
{
    private readonly TimeSpan _rotationPeriod = TimeSpan.FromDays(30);
    private readonly IKeyVaultClient _keyVaultClient;
    private readonly ILogger<SecretRotationService> _logger;
    private Timer _timer;
 
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        _timer = new Timer(DoRotation, null, TimeSpan.Zero, _rotationPeriod);
        _logger.LogInformation("Secret rotation service started");
    }
 
    private async void DoRotation(object state)
    {
        try
        {
            // Генерация нового ключа
            var newKey = GenerateSecureKey();
            
            // Сохранение в Key Vault с указанием версии
            await _keyVaultClient.SetSecretAsync(
                "MyVault", 
                "JwtSigningKey",
                Convert.ToBase64String(newKey),
                new Dictionary<string, string> { { "version", DateTime.UtcNow.ToString("yyyyMMdd") } }
            );
            
            // Период сосуществования старого и нового ключей
            await Task.Delay(TimeSpan.FromHours(1));
            
            // Оповещение о ротации
            await _notificationService.NotifyAdmins("JWT signing key rotated successfully");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error during key rotation");
        }
    }
}

public class TokenService
{
    public TokenPair GenerateTokens(UserDto user)
    {
        // Access token с коротким сроком жизни (15-60 минут)
        var accessToken = GenerateAccessToken(user, TimeSpan.FromMinutes(15));
        
        // Refresh token с более долгим сроком (1-7 дней)
        var refreshToken = GenerateRefreshToken(user.Id, TimeSpan.FromDays(7));
        
        return new TokenPair(accessToken, refreshToken);
    }
    
    public async Task<TokenPair> RefreshTokensAsync(string refreshToken)
    {
        var validationResult = await ValidateRefreshTokenAsync(refreshToken);
        if (!validationResult.IsValid)
        {
            throw new AuthenticationException(validationResult.FailureReason);
        }
        
        // Получаем пользователя по идентификатору из refresh токена
        var user = await _userRepository.GetByIdAsync(validationResult.UserId);
        
        // Инвалидируем старый refresh token
        await _refreshTokenStore.InvalidateTokenAsync(refreshToken);
        
        // Генерируем новую пару токенов
        return GenerateTokens(user);
    }
}

public async Task<bool> IsRefreshTokenReused(string tokenId, Guid userId)
{
    // Получаем историю использования refresh токенов для пользователя
    var usageHistory = await _tokenUsageRepository.GetUserTokenUsageHistoryAsync(userId);
    
    // Проверяем, был ли токен уже использован ранее
    var tokenUsed = usageHistory.Any(h => h.TokenId == tokenId && h.UsedAt < DateTime.UtcNow);
    
    if (tokenUsed)
    {
        // Потенциальная атака повторного использования — автоматически инвалидируем все токены пользователя
        await _refreshTokenStore.InvalidateAllUserTokensAsync(userId);
        await _securityEventService.LogSecurityEventAsync(
            SecurityEventType.TokenReuse,
            userId,
            "Detected refresh token reuse, all tokens invalidated"
        );
        return true;
    }
    
    return false;
}

public class CachedJwksTokenValidator : ITokenValidator
{
    private readonly MemoryCache _keyCache = new MemoryCache(new MemoryCacheOptions());
    private readonly HttpClient _httpClient;
    private readonly string _jwksUri;
    
    public async Task<TokenValidationResult> ValidateTokenAsync(string token)
    {
        // Парсим токен для получения информации о подписи
        var handler = new JwtSecurityTokenHandler();
        var jwtToken = handler.ReadJwtToken(token);
        
        // Получаем идентификатор используемого ключа
        var keyId = jwtToken.Header.Kid;
        
        // Пытаемся получить ключ из кэша
        if (!_keyCache.TryGetValue(keyId, out SecurityKey securityKey))
        {
            // Ключа в кэше нет, загружаем JWKS
            var jwks = await GetJwksAsync();
            
            // Находим нужный ключ по Kid
            var jsonWebKey = jwks.Keys.FirstOrDefault(k => k.Kid == keyId);
            if (jsonWebKey == null)
            {
                return TokenValidationResult.Failed("Signing key not found");
            }
            
            securityKey = jsonWebKey;
            
            // Кэшируем ключ на определенное время
            _keyCache.Set(keyId, securityKey, TimeSpan.FromHours(24));
        }
        
        // Выполняем валидацию с найденным ключом
        try
        {
            var validationParameters = new TokenValidationParameters
            {
                ValidateIssuerSigningKey = true,
                IssuerSigningKey = securityKey,
                ValidateIssuer = true,
                ValidIssuer = "https://auth.example.com",
                ValidateAudience = true,
                ValidAudience = "api",
                ValidateLifetime = true,
                ClockSkew = TimeSpan.Zero
            };
            
            var principal = handler.ValidateToken(token, validationParameters, out _);
            return TokenValidationResult.Success(principal);
        }
        catch (Exception ex)
        {
            return TokenValidationResult.Failed(ex.Message);
        }
    }
    
    private async Task<JsonWebKeySet> GetJwksAsync()
    {
        var response = await _httpClient.GetAsync(_jwksUri);
        response.EnsureSuccessStatusCode();
        
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<JsonWebKeySet>(json);
    }
}

public class AuthorizationIntegrationTests : IClassFixture<WebApplicationFactory<Program>>
{
  private readonly WebApplicationFactory<Program> _factory;
  private readonly string _validToken;
  
  public AuthorizationIntegrationTests(WebApplicationFactory<Program> factory)
  {
      // Настраиваем фабрику с тестовой конфигурацией
      _factory = factory.WithWebHostBuilder(builder =>
      {
          builder.ConfigureTestServices(services =>
          {
              // Подменяем сервис валидации токенов на тестовый
              services.AddSingleton<ITokenValidator>(new TestTokenValidator());
          });
      });
      
      // Создаем тестовый токен для использования в тестах
      _validToken = GenerateTestToken();
  }
  
  [Fact]
  public async Task SecuredEndpoint_WithValidToken_ReturnsOk()
  {
      // Arrange
      var client = _factory.CreateClient();
      client.DefaultRequestHeaders.Authorization = 
          new AuthenticationHeaderValue("Bearer", _validToken);
      
      // Act
      var response = await client.GetAsync("/api/secured-resource");
      
      // Assert
      response.EnsureSuccessStatusCode();
      var content = await response.Content.ReadAsStringAsync();
      Assert.Contains("protected data", content);
  }
  
  [Fact]
  public async Task SecuredEndpoint_WithExpiredToken_ReturnsUnauthorized()
  {
      // Arrange
      var client = _factory.CreateClient();
      var expiredToken = GenerateTestToken(DateTime.UtcNow.AddHours(-1));
      client.DefaultRequestHeaders.Authorization = 
          new AuthenticationHeaderValue("Bearer", expiredToken);
      
      // Act
      var response = await client.GetAsync("/api/secured-resource");
      
      // Assert
      Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
  }
}

public class MicroservicesJwtTests : IDisposable
{
  private readonly TestcontainersContainer _authServiceContainer;
  private readonly TestcontainersContainer _apiGatewayContainer;
  private readonly TestcontainersContainer _resourceServiceContainer;
  private readonly HttpClient _client;
  
  public MicroservicesJwtTests()
  {
      // Инициализация тестовых контейнеров
      _authServiceContainer = new TestcontainersBuilder<TestcontainersContainer>()
          .WithImage("my-auth-service:test")
          .WithEnvironment("JWT_SECRET", "test-secret-key")
          .WithPortBinding(8080, 8080)
          .Build();
          
      // ... инициализация других контейнеров
      
      // Запуск контейнеров
      Task.WhenAll(
          _authServiceContainer.StartAsync(),
          _apiGatewayContainer.StartAsync(),
          _resourceServiceContainer.StartAsync()
      ).GetAwaiter().GetResult();
      
      _client = new HttpClient { BaseAddress = new Uri("http://localhost:8000") };
  }
  
  [Fact]
  public async Task CompleteAuthenticationFlow_Success()
  {
      // Аутентификация и получение токена
      var authResponse = await _client.PostAsJsonAsync("/auth/login", 
          new { Username = "testuser", Password = "password" });
      authResponse.EnsureSuccessStatusCode();
      
      var tokenResponse = await authResponse.Content.ReadFromJsonAsync<TokenResponse>();
      
      // Использование токена для доступа к защищенному ресурсу
      _client.DefaultRequestHeaders.Authorization = 
          new AuthenticationHeaderValue("Bearer", tokenResponse.AccessToken);
          
      var resourceResponse = await _client.GetAsync("/api/protected");
      resourceResponse.EnsureSuccessStatusCode();
  }
  
  public void Dispose()
  {
      Task.WhenAll(
          _authServiceContainer.StopAsync(),
          _apiGatewayContainer.StopAsync(),
          _resourceServiceContainer.StopAsync()
      ).GetAwaiter().GetResult();
  }
}

public class JwtSecurityMonitorMiddleware
{
  private readonly RequestDelegate _next;
  private readonly IDistributedCache _cache;
  private readonly ISecurityEventPublisher _eventPublisher;
  
  public async Task InvokeAsync(HttpContext context)
  {
      var authHeader = context.Request.Headers["Authorization"].FirstOrDefault();
      if (authHeader != null && authHeader.StartsWith("Bearer "))
      {
          var token = authHeader.Substring("Bearer ".Length);
          
          // Проверяем подозрительную активность для данного токена
          await CheckTokenAnomaliesAsync(token, context);
      }
      
      await _next(context);
  }
  
  private async Task CheckTokenAnomaliesAsync(string token, HttpContext context)
  {
      try
      {
          // Парсим токен (без валидации сигнатуры)
          var handler = new JwtSecurityTokenHandler();
          var jwtToken = handler.ReadJwtToken(token);
          
          // Получаем идентификатор пользователя из токена
          var userId = jwtToken.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
          
          if (string.IsNullOrEmpty(userId))
              return;
              
          // Проверяем частоту использования токена
          var usageKey = $"token_usage:{ComputeTokenFingerprint(token)}";
          var currentCount = await _cache.GetStringAsync(usageKey);
          
          int usageCount = 1;
          if (int.TryParse(currentCount, out int count))
          {
              usageCount = count + 1;
          }
          
          await _cache.SetStringAsync(usageKey, usageCount.ToString(), 
              new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5) });
          
          // Если частота слишком высокая - фиксируем инцидент
          if (usageCount > 100) // Пороговое значение для тревоги
          {
              await _eventPublisher.PublishSecurityEventAsync(new SecurityEvent
              {
                  Type = SecurityEventType.JwtAnomalyDetected,
                  UserId = userId,
                  Severity = SecurityEventSeverity.Warning,
                  Details = "Suspicious JWT usage frequency detected",
                  Metadata = new Dictionary<string, string>
                  {
                      ["TokenFingerprint"] = ComputeTokenFingerprint(token),
                      ["RequestIp"] = context.Connection.RemoteIpAddress.ToString(),
                      ["UserAgent"] = context.Request.Headers["User-Agent"]
                  }
              });
          }
      }
      catch
      {
          // В случае ошибки пропускаем проверку
      }
  }
  
  private string ComputeTokenFingerprint(string token)
  {
      using var sha = SHA256.Create();
      var hash = sha.ComputeHash(Encoding.UTF8.GetBytes(token));
      return Convert.ToBase64String(hash);
  }
}

public class SecurityEventHandler : IHostedService
{
  private readonly ISecurityEventSubscriber _eventSubscriber;
  private readonly ITokenBlacklistService _tokenBlacklist;
  private readonly IUserLockService _userLockService;
  
  public Task StartAsync(CancellationToken cancellationToken)
  {
      _eventSubscriber.Subscribe(HandleSecurityEventAsync);
      return Task.CompletedTask;
  }
  
  private async Task HandleSecurityEventAsync(SecurityEvent securityEvent)
  {
      switch (securityEvent.Type)
      {
          case SecurityEventType.JwtAnomalyDetected:
              if (securityEvent.Severity >= SecurityEventSeverity.Warning)
              {
                  // Блокируем токен
                  if (securityEvent.Metadata.TryGetValue("TokenFingerprint", out var fingerprint))
                  {
                      await _tokenBlacklist.BlacklistByFingerprintAsync(
                          fingerprint, 
                          "Suspicious activity detected");
                  }
                  
                  // При серьезных инцидентах временно блокируем аккаунт
                  if (securityEvent.Severity >= SecurityEventSeverity.Critical)
                  {
                      await _userLockService.LockUserTemporarilyAsync(
                          securityEvent.UserId, 
                          TimeSpan.FromMinutes(30),
                          "Suspicious JWT activity");
                  }
              }
              break;
      }
  }
}

public class LightweightJwtValidator
{
    private readonly string _issuer;
    private readonly string _audience;
    private readonly byte[] _keyBytes;
    
    // Инициализация только необходимых компонентов
    public LightweightJwtValidator(string issuer, string audience, string base64Key)
    {
        _issuer = issuer;
        _audience = audience;
        _keyBytes = Convert.FromBase64String(base64Key);
    }
    
    public ClaimsPrincipal ValidateToken(string token)
    {
        var tokenHandler = new JwtSecurityTokenHandler();
        var validationParameters = new TokenValidationParameters
        {
            // Только необходимый минимум проверок для снижения вычислительных затрат
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(_keyBytes),
            ValidateLifetime = true,
            ValidateIssuer = !string.IsNullOrEmpty(_issuer),
            ValidIssuer = _issuer,
            ValidateAudience = !string.IsNullOrEmpty(_audience),
            ValidAudience = _audience,
            // Разрешаем небольшое расхождение времени из-за природы распределенных систем
            ClockSkew = TimeSpan.FromMinutes(2)
        };
        
        return tokenHandler.ValidateToken(token, validationParameters, out _);
    }
}

public static class SecuredFunction
{
    // Статическое поле для сохранения экземпляра между вызовами (если функция не перезапускается)
    private static readonly LightweightJwtValidator _validator;
    
    static SecuredFunction()
    {
        // Инициализация при первом запуске функции
        var issuer = Environment.GetEnvironmentVariable("JWT_ISSUER");
        var audience = Environment.GetEnvironmentVariable("JWT_AUDIENCE");
        var keyBase64 = Environment.GetEnvironmentVariable("JWT_KEY");
        
        _validator = new LightweightJwtValidator(issuer, audience, keyBase64);
    }
    
    [FunctionName("SecuredEndpoint")]
    public static async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
        ILogger log)
    {
        log.LogInformation("Processing secured request");
        
        try
        {
            // Извлечение и валидация токена
            string authHeader = req.Headers["Authorization"];
            if (string.IsNullOrEmpty(authHeader) || !authHeader.StartsWith("Bearer "))
            {
                return new UnauthorizedResult();
            }
            
            var token = authHeader.Substring("Bearer ".Length);
            var principal = _validator.ValidateToken(token);
            
            // Проверка необходимых разрешений
            if (!principal.IsInRole("Reader"))
            {
                return new ForbidResult();
            }
            
            // Обработка основной логики...
            return new OkObjectResult(new { message = "Secured data accessed" });
        }
        catch (Exception ex)
        {
            log.LogError(ex, "Authorization failed");
            return new UnauthorizedResult();
        }
    }
}

public class KubernetesAdaptedJwksProvider : IJwksProvider
{
    private readonly IDistributedCache _distributedCache;
    private readonly HttpClient _httpClient;
    private readonly string _jwksUri;
    private readonly TimeSpan _cacheDuration;
    private readonly SemaphoreSlim _cacheLock = new SemaphoreSlim(1, 1);
    
    public KubernetesAdaptedJwksProvider(
        IDistributedCache distributedCache,
        HttpClient httpClient,
        string jwksUri,
        TimeSpan? cacheDuration = null)
    {
        _distributedCache = distributedCache;
        _httpClient = httpClient;
        _jwksUri = jwksUri;
        _cacheDuration = cacheDuration ?? TimeSpan.FromHours(24);
    }
    
    public async Task<JsonWebKeySet> GetJsonWebKeySetAsync()
    {
        var cacheKey = $"jwks:{_jwksUri}";
        var cachedJwks = await _distributedCache.GetStringAsync(cacheKey);
        
        if (!string.IsNullOrEmpty(cachedJwks))
        {
            return JsonSerializer.Deserialize<JsonWebKeySet>(cachedJwks);
        }
        
        // Используем семафор для предотвращения "гонок" при обновлении кэша
        await _cacheLock.WaitAsync();
        try
        {
            // Повторная проверка кэша после получения блокировки
            cachedJwks = await _distributedCache.GetStringAsync(cacheKey);
            if (!string.IsNullOrEmpty(cachedJwks))
            {
                return JsonSerializer.Deserialize<JsonWebKeySet>(cachedJwks);
            }
            
            // Реальный запрос к эндпоинту JWKS
            var response = await _httpClient.GetAsync(_jwksUri);
            response.EnsureSuccessStatusCode();
            
            var jwksJson = await response.Content.ReadAsStringAsync();
            var jwks = JsonSerializer.Deserialize<JsonWebKeySet>(jwksJson);
            
            // Кэширование с учетом скользящего окна в Redis
            await _distributedCache.SetStringAsync(cacheKey, jwksJson, new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = _cacheDuration,
                // Добавляем случайное смещение для предотвращения одновременного истечения кэша
                // на всех экземплярах (снижаем нагрузку на JWKS-эндпоинт)
                SlidingExpiration = TimeSpan.FromMinutes(Random.Shared.Next(10, 60))
            });
            
            return jwks;
        }
        finally
        {
            _cacheLock.Release();
        }
    }
    
    public async Task<SecurityKey> GetSigningKeyAsync(string keyId)
    {
        var jwks = await GetJsonWebKeySetAsync();
        var key = jwks.Keys.FirstOrDefault(k => k.Kid == keyId);
        
        if (key == null)
        {
            throw new SecurityTokenSignatureKeyNotFoundException($"Unable to find key with ID: {keyId}");
        }
        
        return new JsonWebKey
        {
            Kid = key.Kid,
            Kty = key.Kty,
            E = key.E,
            N = key.N,
            X = key.X,
            Y = key.Y,
            Crv = key.Crv,
            Alg = key.Alg
        };
    }
}

// В методе ConfigureServices
services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = Configuration.GetConnectionString("Redis");
    options.InstanceName = "JwtAuth_";
});
 
services.AddHttpClient<KubernetesAdaptedJwksProvider>();
services.AddSingleton<IJwksProvider>(provider =>
{
    var cache = provider.GetRequiredService<IDistributedCache>();
    var httpClientFactory = provider.GetRequiredService<IHttpClientFactory>();
    var httpClient = httpClientFactory.CreateClient();
    
    return new KubernetesAdaptedJwksProvider(
        cache,
        httpClient,
        Configuration["Authentication:JwksUri"]
    );
});

public class OptimizedJwtGenerator
{
    private readonly SigningCredentials _credentials;
    private readonly string _issuer;
    private readonly string _audience;
    
    public OptimizedJwtGenerator(SigningCredentials credentials, string issuer, string audience)
    {
        _credentials = credentials;
        _issuer = issuer;
        _audience = audience;
    }
    
    public string GenerateCompactToken(UserInfo user, TimeSpan expiry)
    {
        // Используем короткие названия клеймов для уменьшения размера
        var claims = new List<Claim>
        {
            new Claim("sub", user.Id.ToString()),
            // Используем код роли вместо полного названия
            new Claim("rol", string.Join(",", user.Roles.Select(r => GetRoleCode(r))))
        };
        
        // Добавляем права доступа только если они отличаются от стандартных для ролей
        if (user.HasCustomPermissions)
        {
            claims.Add(new Claim("prm", string.Join(",", user.Permissions.Select(p => GetPermissionCode(p)))));
        }
        
        // Избегаем избыточной информации в токене
        if (user.TenantId.HasValue)
        {
            claims.Add(new Claim("tid", user.TenantId.Value.ToString()));
        }
        
        var tokenDescriptor = new SecurityTokenDescriptor
        {
            Subject = new ClaimsIdentity(claims),
            Expires = DateTime.UtcNow.Add(expiry),
            Issuer = _issuer,
            Audience = _audience,
            SigningCredentials = _credentials,
            IssuedAt = DateTime.UtcNow
        };
        
        var tokenHandler = new JwtSecurityTokenHandler();
        var token = tokenHandler.CreateToken(tokenDescriptor);
        return tokenHandler.WriteToken(token);
    }
    
    // Преобразование полной роли в код (например, "Administrator" -> "A")
    private string GetRoleCode(string role) => role switch
    {
        "Administrator" => "A",
        "Manager" => "M",
        "User" => "U",
        "ReadOnly" => "R",
        _ => role
    };
    
    // Аналогично для прав доступа
    private string GetPermissionCode(string permission) => permission switch
    {
        "ReadData" => "R",
        "WriteData" => "W",
        "DeleteData" => "D",
        "ExportData" => "E",
        _ => permission
    };
}

public static class CompactClaimsDecoder
{
    public static IEnumerable<Claim> ExpandCompactClaims(ClaimsPrincipal principal)
    {
        var expandedClaims = new List<Claim>();
        
        // Декодирование ролей
        var rolesClaim = principal.FindFirst("rol");
        if (rolesClaim != null)
        {
            foreach (var roleCode in rolesClaim.Value.Split(','))
            {
                var fullRole = GetFullRoleName(roleCode);
                expandedClaims.Add(new Claim(ClaimTypes.Role, fullRole));
            }
        }
        
        // Декодирование прав доступа
        var permissionsClaim = principal.FindFirst("prm");
        if (permissionsClaim != null)
        {
            foreach (var permCode in permissionsClaim.Value.Split(','))
            {
                var fullPermission = GetFullPermissionName(permCode);
                expandedClaims.Add(new Claim("permission", fullPermission));
            }
        }
        
        return expandedClaims;
    }
    
    private static string GetFullRoleName(string code) => code switch
    {
        "A" => "Administrator",
        "M" => "Manager",
        "U" => "User",
        "R" => "ReadOnly",
        _ => code
    };
    
    private static string GetFullPermissionName(string code) => code switch
    {
        "R" => "ReadData",
        "W" => "WriteData",
        "D" => "DeleteData",
        "E" => "ExportData",
        _ => code
    };
}

[FunctionName("RefreshToken")]
public static async Task<IActionResult> RefreshTokenFunction(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
    [CosmosDB(
        databaseName: "JwtTokensDb",
        collectionName: "RefreshTokens",
        ConnectionStringSetting = "CosmosDbConnection")]
    IAsyncCollector<RefreshTokenRecord> refreshTokensOut,
    [CosmosDB(
        databaseName: "JwtTokensDb",
        collectionName: "RefreshTokens",
        ConnectionStringSetting = "CosmosDbConnection",
        SqlQuery = "SELECT * FROM c WHERE c.token = {token}")]
    IEnumerable<RefreshTokenRecord> existingTokens,
    ILogger log)
{
    log.LogInformation("Processing token refresh request");
    
    try
    {
        // Десериализация запроса
        string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
        var request = JsonSerializer.Deserialize<RefreshTokenRequest>(requestBody);
        
        if (string.IsNullOrEmpty(request?.RefreshToken))
        {
            return new BadRequestObjectResult("Invalid refresh token");
        }
        
        // Проверка существования и валидности refresh-токена
        var existingToken = existingTokens.FirstOrDefault();
        if (existingToken == null || existingToken.Expires < DateTime.UtcNow || existingToken.IsRevoked)
        {
            return new UnauthorizedResult();
        }
        
        // Получаем информацию о пользователе (можно использовать CosmosDB или другое хранилище)
        var userInfo = await GetUserInfoAsync(existingToken.UserId);
        
        // Генерируем новый Access токен
        var tokenGenerator = GetTokenGenerator();
        var accessToken = tokenGenerator.GenerateAccessToken(userInfo);
        
        // Генерируем новый Refresh токен с ротацией
        var newRefreshToken = Guid.NewGuid().ToString("N");
        
        // Сохраняем новый Refresh токен в Cosmos DB
        await refreshTokensOut.AddAsync(new RefreshTokenRecord
        {
            Id = Guid.NewGuid().ToString(),
            Token = newRefreshToken,
            UserId = existingToken.UserId,
            CreatedAt = DateTime.UtcNow,
            Expires = DateTime.UtcNow.AddDays(7),
            IsRevoked = false,
            ReplacedByToken = null
        });
        
        // Отмечаем старый токен как использованный
        existingToken.IsRevoked = true;
        existingToken.ReplacedByToken = newRefreshToken;
        await refreshTokensOut.AddAsync(existingToken);
        
        return new OkObjectResult(new
        {
            accessToken,
            refreshToken = newRefreshToken
        });
    }
    catch (Exception ex)
    {
        log.LogError(ex, "Error processing refresh token");
        return new StatusCodeResult(500);
    }
}
 
private static async Task<UserInfo> GetUserInfoAsync(string userId)
{
    // В реальном приложении здесь бы был запрос к базе данных или сервису пользователей
    // Для демонстрации используем заглушку
    await Task.Delay(10); // Имитация асинхронного вызова
    return new UserInfo
    {
        Id = userId,
        Username = "user_" + userId,
        Roles = new[] { "User" },
        Permissions = new[] { "ReadData" }
    };
}
 
private static TokenGenerator GetTokenGenerator()
{
    var issuer = Environment.GetEnvironmentVariable("JWT_ISSUER");
    var audience = Environment.GetEnvironmentVariable("JWT_AUDIENCE");
    var keyBase64 = Environment.GetEnvironmentVariable("JWT_KEY");
    var keyBytes = Convert.FromBase64String(keyBase64);
    
    var securityKey = new SymmetricSecurityKey(keyBytes);
    var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
    
    return new TokenGenerator(credentials, issuer, audience);
}

public static class AzureAdAuthorizedFunction
{
    [FunctionName("SecuredByAzureAd")]
    public static async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
        ILogger log)
    {
        log.LogInformation("Processing Azure AD secured request");
        
        try
        {
            // Конфигурация Azure AD из настроек
            var tenantId = Environment.GetEnvironmentVariable("AzureAd:TenantId");
            var audience = Environment.GetEnvironmentVariable("AzureAd:Audience");
            
            // Извлечение токена
            var authHeader = req.Headers["Authorization"].FirstOrDefault();
            if (string.IsNullOrEmpty(authHeader) || !authHeader.StartsWith("Bearer "))
            {
                return new UnauthorizedResult();
            }
            
            var token = authHeader.Substring("Bearer ".Length);
            
            // Настройка параметров валидации
            var configManager = new ConfigurationManager<OpenIdConnectConfiguration>(
                $"https://login.microsoftonline.com/{tenantId}/v2.0/.well-known/openid-configuration",
                new OpenIdConnectConfigurationRetriever());
            
            var config = await configManager.GetConfigurationAsync(CancellationToken.None);
            
            var validationParameters = new TokenValidationParameters
            {
                ValidateIssuer = true,
                ValidIssuer = $"https://sts.windows.net/{tenantId}/",
                ValidateAudience = true,
                ValidAudience = audience,
                ValidateLifetime = true,
                IssuerSigningKeys = config.SigningKeys
            };
            
            // Валидация токена
            var handler = new JwtSecurityTokenHandler();
            var principal = handler.ValidateToken(token, validationParameters, out _);
            
            // Проверка необходимых разрешений (Azure AD app roles)
            if (!principal.Claims.Any(c => c.Type == "roles" && c.Value == "Function.Access"))
            {
                return new ForbidResult();
            }
            
            // Обработка основной логики
            var userId = principal.FindFirst("oid")?.Value ?? "unknown";
            return new OkObjectResult(new { 
                message = $"Hello, authenticated user {userId}!" 
            });
        }
        catch (Exception ex)
        {
            log.LogError(ex, "Authentication or authorization failed");
            return new UnauthorizedResult();
        }
    }
}

public class MetricsMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMetricFactory _metricFactory;
    
    public MetricsMiddleware(RequestDelegate next, IMetricFactory metricFactory)
    {
        _next = next;
        _metricFactory = metricFactory;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        var path = context.Request.Path.Value;
        
        // Отслеживаем только эндпоинты аутентификации
        if (path?.StartsWith("/auth/token") == true)
        {
            var stopwatch = Stopwatch.StartNew();
            try
            {
                await _next(context);
            }
            finally
            {
                stopwatch.Stop();
                var statusCode = context.Response.StatusCode;
                
                // Записываем метрику времени генерации токена
                _metricFactory.CreateHistogram(
                    "jwt_token_generation_duration_seconds",
                    "Time spent generating JWT tokens",
                    new[] { "status" })
                    .Observe(stopwatch.Elapsed.TotalSeconds, 
                        new[] { statusCode.ToString() });
                
                // Увеличиваем счетчик запросов токенов
                _metricFactory.CreateCounter(
                    "jwt_token_requests_total",
                    "Total number of JWT token requests",
                    new[] { "status" })
                    .Increment(new[] { statusCode.ToString() });
            }
        }
        else
        {
            await _next(context);
        }
    }
}

public class ResiliencyJwtValidator : IJwtValidator
{
    private readonly IJwtValidator _innerValidator;
    private readonly ICircuitBreakerFactory _circuitBreakerFactory;
    private readonly ILogger<ResiliencyJwtValidator> _logger;
    
    public ResiliencyJwtValidator(
        IJwtValidator innerValidator,
        ICircuitBreakerFactory circuitBreakerFactory,
        ILogger<ResiliencyJwtValidator> logger)
    {
        _innerValidator = innerValidator;
        _circuitBreakerFactory = circuitBreakerFactory;
        _logger = logger;
    }
    
    public async Task<TokenValidationResult> ValidateTokenAsync(string token)
    {
        // Получаем именованный circuit breaker для операций валидации токенов
        var circuitBreaker = _circuitBreakerFactory.CreateCircuitBreaker("token-validation");
        
        try
        {
            // Выполняем операцию через circuit breaker
            return await circuitBreaker.ExecuteAsync(async () => 
                await _innerValidator.ValidateTokenAsync(token));
        }
        catch (BrokenCircuitException ex)
        {
            _logger.LogWarning(ex, "JWT validation circuit is broken. Using fallback strategy.");
            
            // Применяем стратегию запасного режима:
            // 1. Проверяем локально только базовые аспекты (подпись, срок действия)
            // 2. Ограничиваем права доступа до минимально необходимых
            // 3. Устанавливаем флаг degraded mode для бизнес-логики
            
            var fallbackResult = await ExecuteFallbackValidationAsync(token);
            
            // Помечаем результат как полученный в режиме деградации
            fallbackResult.IssuedInDegradedMode = true;
            
            return fallbackResult;
        }
    }
    
    private async Task<TokenValidationResult> ExecuteFallbackValidationAsync(string token)
    {
        try
        {
            // Упрощенная локальная валидация без обращения к внешним сервисам
            // ...
            
            // Создаем урезанный набор клеймов для ограниченного доступа
            var claims = new List<Claim>
            {
                new Claim("degraded_mode", "true"),
                // Минимальные разрешения для базовой функциональности
                new Claim(ClaimTypes.Role, "BasicAccess")
            };
            
            var identity = new ClaimsIdentity(claims, "Bearer");
            var principal = new ClaimsPrincipal(identity);
            
            return TokenValidationResult.Success(principal);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Fallback validation failed");
            return TokenValidationResult.Failed("Both primary and fallback validation failed");
        }
    }
}

services.AddSingleton<IJwtValidator, ActualJwtValidator>();
services.Decorate<IJwtValidator, ResiliencyJwtValidator>();
 
services.AddCircuitBreakerFactory(options =>
{
    options.AddPolicy("token-validation", new CircuitBreakerOptions
    {
        FailureThreshold = 0.5, // 50% отказов
        SamplingDuration = TimeSpan.FromMinutes(2),
        MinimumThroughput = 10,
        DurationOfBreak = TimeSpan.FromMinutes(1),
        NotificationCallback = (cb, state, duration, ex) =>
        {
            if (state == CircuitState.Open)
            {
                // Запись в лог и отправка оповещения об открытии circuit breaker
                var logger = serviceProvider.GetRequiredService<ILogger<ResiliencyJwtValidator>>();
                logger.LogError(ex, "JWT validation circuit breaker opened for {Duration}", duration);
                
                // Оповещение через систему мониторинга
                var metrics = serviceProvider.GetRequiredService<IMetricFactory>();
                metrics.CreateCounter("jwt_circuit_breaker_trips_total").Increment();
            }
        }
    });
});