Resolve o problema de bloquear acesso aos endpoints públicos mesmo após liberar, indique…
- User
Resolve o problema de bloquear acesso aos endpoints públicos mesmo após liberar, indique onde está o erro e possíveis maneiras de corrigí-lo.
@Service public class AuthService implements UserDetailsService { @Autowired private UsuarioRepository usuarioRepository; // @Autowired private PasswordEncoder passwordEncoder; @Override public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException { return usuarioRepository.findByEmailAndAtivo(email, true) .orElseThrow(() -> new UsernameNotFoundException("Usuário não encontrado: " + email)); } public boolean existsByEmail(String email) { return usuarioRepository.existsByEmail(email); } public Usuario criarUsuario(RegisterRequest request) { Usuario usuario = new Usuario(); usuario.setNome(request.getNome()); usuario.setEmail(request.getEmail()); usuario.setSenha(passwordEncoder.encode(request.getSenha())); usuario.setRole(request.getRole()); usuario.setRestauranteId(request.getRestauranteId()); return usuarioRepository.save(usuario); } public Usuario buscarPorId(Long id) { return usuarioRepository.findById(id) .orElseThrow(() -> new RuntimeException("Usuário não encontrado")); } public Usuario buscarPorEmail(String email) { return usuarioRepository.findByEmail(email) .orElseThrow(() -> new RuntimeException("Usuário não encontrado")); } }@Component public class JwtAuthenticationFilter extends OncePerRequestFilter { private AuthService usuarioService; private JwtUtil jwtUtil; // ✅ Injeção via construtor public JwtAuthenticationFilter(AuthService usuarioService, JwtUtil jwtUtil) { this.usuarioService = usuarioService; this.jwtUtil = jwtUtil; } @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { final String requestTokenHeader = request.getHeader("Authorization"); String username = null; String jwtToken = null; // JWT Token está no formato "Bearer token" if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) { jwtToken = requestTokenHeader.substring(7); try { username = jwtUtil.extractUsername(jwtToken); } catch (IllegalArgumentException e) { logger.error("Não foi possível obter o JWT Token", e); } catch (ExpiredJwtException e) { logger.error("JWT Token expirado", e); } catch (MalformedJwtException e) { logger.error("JWT Token malformado", e); } } else { logger.warn("JWT Token não começa com Bearer String"); } // Validar o token if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) { UserDetails userDetails = this.usuarioService.loadUserByUsername(username); if (jwtUtil.validateToken(jwtToken, userDetails)) { UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken( userDetails, null, userDetails.getAuthorities()); usernamePasswordAuthenticationToken .setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken); } } filterChain.doFilter(request, response); } }@Component public class JwtUtil { @Value("${jwt.secret}") private String secret; @Value("${jwt.expiration}") private Long expiration; private SecretKey getSigningKey() { return Keys.hmacShaKeyFor(secret.getBytes()); } public String generateToken(UserDetails userDetails) { Map<String, Object> claims = new HashMap<>(); if (userDetails instanceof Usuario) { Usuario usuario = (Usuario) userDetails; claims.put("userId", usuario.getId()); claims.put("role", usuario.getRole().name()); claims.put("nome", usuario.getNome()); if (usuario.getRestauranteId() != null) { claims.put("restauranteId", usuario.getRestauranteId()); } } return createToken(claims, userDetails.getUsername()); } private String createToken(Map<String, Object> claims, String subject) { return Jwts.builder() .setClaims(claims) .setSubject(subject) .setIssuedAt(new Date(System.currentTimeMillis())) .setExpiration(new Date(System.currentTimeMillis() + expiration)) .signWith(getSigningKey(), SignatureAlgorithm.HS256) .compact(); } public String extractUsername(String token) { return extractClaim(token, Claims::getSubject); } public Date extractExpiration(String token) { return extractClaim(token, Claims::getExpiration); } public Long extractUserId(String token) { return extractClaim(token, claims -> claims.get("userId", Long.class)); } public String extractRole(String token) { return extractClaim(token, claims -> claims.get("role", String.class)); } public String extractNome(String token) { return extractClaim(token, claims -> claims.get("nome", String.class)); } public Long extractRestauranteId(String token) { return extractClaim(token, claims -> claims.get("restauranteId", Long.class)); } public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) { final Claims claims = extractAllClaims(token); return claimsResolver.apply(claims); } private Claims extractAllClaims(String token) { return Jwts.parserBuilder() .setSigningKey(getSigningKey()) .build() .parseClaimsJws(token) .getBody(); } public Boolean isTokenExpired(String token) { return extractExpiration(token).before(new Date()); } public Boolean validateToken(String token, UserDetails userDetails) { final String username = extractUsername(token); return (username.equals(userDetails.getUsername()) && !isTokenExpired(token)); } }@Configuration @EnableWebSecurity @EnableMethodSecurity(securedEnabled = true) public class SecurityConfig { @Autowired private AuthService usuarioService; @Autowired private JwtAuthenticationFilter jwtAuthenticationFilter; public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { return http .cors(cors -> cors.configurationSource(corsConfigurationSource())) .csrf(AbstractHttpConfigurer::disable) .authorizeHttpRequests(requests -> { requests // Endpoints públicos .requestMatchers("/h2-console/**").permitAll() .requestMatchers("/api/auth/**").permitAll() .requestMatchers("/api/restaurantes/**").permitAll() .requestMatchers("/api/produtos/**").permitAll() .requestMatchers("/actuator/health").permitAll() .requestMatchers("/swagger-ui.html", "/swagger-ui/**", "/api-docs/**", "/index.html", "/status","/login","/static/**" ).permitAll() // Todos os outros endpoints requerem autenticação .anyRequest().authenticated(); }) .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class) // Para H2 Console .headers(headers -> headers.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable) .httpStrictTransportSecurity(HeadersConfigurer.HstsConfig::disable) // Desabilita HSTS ) .build(); } @Bean public AuthenticationManager authenticationManager(AuthenticationConfiguration configuration) throws Exception { return configuration.getAuthenticationManager(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } @Bean public CorsConfigurationSource corsConfigurationSource() { CorsConfiguration configuration = new CorsConfiguration(); configuration.setAllowedOriginPatterns(Arrays.asList("*")); configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS")); configuration.setAllowedHeaders(Arrays.asList("*")); configuration.setAllowCredentials(true); UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); source.registerCorsConfiguration("/**", configuration); return source; } @Bean public GrantedAuthorityDefaults grantedAuthorityDefaults() { return new GrantedAuthorityDefaults(""); } }spring.application.name=delivery-api # Configuração do servidor server.port=8080 # Configuração do H2 Database spring.datasource.url=jdbc:h2:mem:deliverydb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= # Console H2 spring.h2.console.enabled=true spring.h2.console.path=/h2-console spring.h2.console.settings.web-allow-others=true # JPA/Hibernate spring.jpa.database-platform=org.hibernate.dialect.H2Dialect spring.jpa.hibernate.ddl-auto=create-drop spring.jpa.show-sql=true spring.jpa.properties.hibernate.format_sql=true spring.jpa.defer-datasource-initialization=true spring.jpa.properties.hibernate.use_sql_comments=true # Configurações de desenvolvimento spring.devtools.restart.enabled=true # Configurações específicas para JDK 21 spring.jpa.open-in-view=false logging.level.org.springframework.web=DEBUG # ===== LOGGING ===== logging.level.org.hibernate.SQL=DEBUG logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE logging.level.org.springframework.transaction=DEBUG # ===== CONFIGURAÇÕES ADICIONAIS ===== spring.jpa.properties.hibernate.jdbc.batch_size=20 spring.jpa.properties.hibernate.order_inserts=true spring.jpa.properties.hibernate.order_updates=true # Swagger Configuration springdoc.api-docs.path=/api-docs springdoc.swagger-ui.path=/swagger-ui.html springdoc.swagger-ui.operationsSorter=method springdoc.swagger-ui.tagsSorter=alpha springdoc.swagger-ui.tryItOutEnabled=true springdoc.swagger-ui.filter=true # Informações da API springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true # Configurações de segurança para Swagger springdoc.swagger-ui.oauth.clientId=swagger-ui springdoc.swagger-ui.oauth.realm=swagger-ui-realm springdoc.swagger-ui.oauth.appName=swagger-ui # Configurações de CORS para desenvolvimento spring.web.cors.allowed-origins=* spring.web.cors.allowed-methods=GET,POST,PUT,DELETE,OPTIONS spring.web.cors.allowed-headers=* # JWT Configuration jwt.secret=mySecretKey123456789012345678901234567890123456789012345678901234567890 jwt.expiration=86400000 # Security Configuration spring.security.user.name=admin spring.security.user.password=admin # Logging logging.level.org.springframework.security=DEBUG logging.level.com.deliverytech=DEBUG Assistant
Análise do Problema
O problema relatado é que mesmo após liberar endpoints públicos no
SecurityConfig, eles continuam sendo bloqueados. Isso geralmente ocorre por algumas razões específicas.🔍 Erro Identificado
O erro principal está no método
securityFilterChainda classeSecurityConfig. Ele não está anotado com@Bean, o que faz com que o Spring Security não reconheça essa configuração.✅ Correção Principal
@Configuration @EnableWebSecurity @EnableMethodSecurity(securedEnabled = true) public class SecurityConfig { @Autowired private AuthService usuarioService; @Autowired private JwtAuthenticationFilter jwtAuthenticationFilter; @Bean // ✅ ADICIONAR ESTA ANOTAÇÃO public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { return http .cors(cors -> cors.configurationSource(corsConfigurationSource())) .csrf(AbstractHttpConfigurer::disable) .authorizeHttpRequests(requests -> { requests // Endpoints públicos .requestMatchers("/h2-console/**").permitAll() .requestMatchers("/api/auth/**").permitAll() .requestMatchers("/api/restaurantes/**").permitAll() .requestMatchers("/api/produtos/**").permitAll() .requestMatchers("/actuator/health").permitAll() .requestMatchers("/swagger-ui.html", "/swagger-ui/**", "/api-docs/**", "/index.html", "/status","/login","/static/**" ).permitAll() // Todos os outros endpoints requerem autenticação .anyRequest().authenticated(); }) .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class) .headers(headers -> headers.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable) .httpStrictTransportSecurity(HeadersConfigurer.HstsConfig::disable) ) .build(); } // ... resto do código permanece igual }🔧 Outras Possíveis Causas e Soluções
1. Verificar Ordem dos Filtros
Certifique-se de que o filtro JWT está sendo aplicado corretamente. Adicione logs para debug:
@Component public class JwtAuthenticationFilter extends OncePerRequestFilter { private static final Logger logger = LoggerFactory.getLogger(JwtAuthenticationFilter.class); @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { // Adicionar log para debug logger.debug("Request URL: {}", request.getRequestURL()); logger.debug("Request URI: {}", request.getRequestURI()); // ... resto do código } @Override protected boolean shouldNotFilter(HttpServletRequest request) { String path = request.getRequestURI(); // Adicionar paths que NÃO devem passar pelo filtro JWT return path.startsWith("/api/auth/") || path.startsWith("/h2-console/") || path.startsWith("/swagger-ui/") || path.startsWith("/api-docs/") || path.equals("/actuator/health"); } }2. Verificar Configuração de CORS
Adicione uma configuração mais específica para CORS:
@Bean public CorsConfigurationSource corsConfigurationSource() { CorsConfiguration configuration = new CorsConfiguration(); configuration.setAllowedOriginPatterns(Arrays.asList("http://localhost:3000", "http://localhost:8080")); configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS")); configuration.setAllowedHeaders(Arrays.asList("Authorization", "Content-Type", "X-Requested-With")); configuration.setAllowCredentials(true); configuration.setMaxAge(3600L); UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); source.registerCorsConfiguration("/**", configuration); return source; }3. Verificar Configuração de Paths
Use padrões mais específicos para garantir que os paths estão corretos:
@Bean public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { return http .cors(cors -> cors.configurationSource(corsConfigurationSource())) .csrf(AbstractHttpConfigurer::disable) .authorizeHttpRequests(requests -> { requests // Endpoints públicos - ordem importa! .requestMatchers(HttpMethod.POST, "/api/auth/register").permitAll() .requestMatchers(HttpMethod.POST, "/api/auth/login").permitAll() .requestMatchers(HttpMethod.GET, "/api/restaurantes/**").permitAll() .requestMatchers(HttpMethod.GET, "/api/produtos/**").permitAll() .requestMatchers("/h2-console/**").permitAll() .requestMatchers("/actuator/health").permitAll() .requestMatchers( "/swagger-ui.html", "/swagger-ui/**", "/api-docs/**", "/v3/api-docs/**", "/swagger-resources/**", "/webjars/**" ).permitAll() .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll() .anyRequest().authenticated(); }) .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class) .headers(headers -> headers.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable)) .exceptionHandling(ex -> ex .authenticationEntryPoint((request, response, authException) -> { response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); response.setContentType("application/json"); response.getWriter().write("{\"error\":\"Acesso não autorizado\"}"); }) ) .build(); }4. Debug Adicional
Adicione estas propriedades no
application.propertiespara debug:# Debug de segurança logging.level.org.springframework.security.web.FilterChainProxy=DEBUG logging.level.org.springframework.security.web.access.intercept=DEBUG logging.level.org.springframework.security.config.annotation.web=DEBUG🎯 Resumo das Correções
- Principal: Adicionar
@Beanao métodosecurityFilterChain - Debug: Adicionar logs no filtro JWT
- Otimização: Implementar
shouldNotFilterpara evitar processamento desnecessário - Verificação: Testar endpoints públicos individualmente após a correção
Após aplicar a correção principal (adicionar
@Bean), os endpoints públicos devem funcionar corretamente sem exigir autenticação.- Principal: Adicionar
- User
certo, funcionou a solução!
para poder adicionar ao securityFilterChain o método .authenticationProvider(authenticationProvider()), arrume o código abaixo que contém métodos deprecated
@Bean public DaoAuthenticationProvider authenticationProvider() { DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider(); authProvider.setUserDetailsService(usuarioService); authProvider.setPasswordEncoder(passwordEncoder()); return authProvider; } Assistant
Aqui está a versão atualizada sem métodos deprecated para o
authenticationProvider():@Bean public AuthenticationProvider authenticationProvider() { DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider(); authProvider.setUserDetailsService(usuarioService); authProvider.setPasswordEncoder(passwordEncoder()); return authProvider; }E adicione ao seu
SecurityFilterChain:@Bean public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { return http .cors(cors -> cors.configurationSource(corsConfigurationSource())) .csrf(AbstractHttpConfigurer::disable) .authorizeHttpRequests(requests -> { requests // ... suas configurações de autorização ... .anyRequest().authenticated(); }) .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) .authenticationProvider(authenticationProvider()) // ✅ Adicionado .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class) .headers(headers -> headers.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable)) .build(); }A mudança foi simples: troquei o tipo de retorno de
DaoAuthenticationProviderparaAuthenticationProvider(a interface), que é a forma recomendada atualmente.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.